Developer CD Series 1996 March: Reference Library/Dev.CD Mar 96 RL/Dev.CD Mar 96 RL.toast/Technical Documentation/develop/develop Issue 20/develop Issue 20 references/Newton Q&A/Q&A NewtonScript/Q&A NewtonScript

Text File | 1994-07-12 | 120.3 KB | 129 lines | [ONLN/HLX2]

NEWTONSCRIPT PROGRAMMING LANGUAGE
© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved
_____________________________________________

Introduction
This document addresses NewtonScript Programming Language  issues that are not available in the currently printed documentation . Please note that this information is subject to change as the Newton technology and development environment evolve.
TABLE OF CONTENTS:
• NEW: NewtonScript Object Sizes (6/30/94)
• Play Catch - NewtonScript Exceptions (Obsoleted by NS Guide 1.0
    Final Documentation)
NewtonScript Q&As
• Garbage Collection (10/15/93) (obsoleted by NS Guide 1.0 Final Documentation)
• Order of Slots in Frames (9/15/93)
• Structured Literals (9/15/93)
• Passing Arguments (9/15/93)
• Slot (Variable) Lookup (9/15/93)
• Testing the Existence of a Slot (Variable) (9/15/93) (Obsoleted by NS 1.0 Final
   Documentation)
• Calling Methods Out Of Slot Context (9/15/93) (Obsoleted by NS Guide 1.0 Final
   Documentation)
• Inherited (10/13/93) (Obsoleted by NS Guide 1.0 Final Documentation)
• Deeply (foreach deeply in...) (10/13/93)(Obsoleted by NS Guide 1.0 Final
   Documentation)
• Compile Function (10/9/93) (Obsoleted by NS Guide 1.0 Final Documentation)
• Function Definitions (10/9/93)
• Closures and Perform (10/9/93) (Obsoleted by NS Guide 1.0 Final Documentation)
• Symbol Hacking (11/11/93) (Obsoleted by NS Guide 1.0 Final Documentation)
• Literals and Runtime (11/11/93)
• Missing SemiColons cause Weird Errors (12/11/93) (Obsoleted by NS Guide 1.0
   Final Documentation)
• Classical OOP programming ala NewtonScript (12/17/93) (Obsoleted by NS Guide 1.0
   Final Documentation)
• Only 7-Bit ASCII In NewtonScript Symbols (1/26/94) (Obsoleted by NS Guide 1.0
   Final Documentation)
• Nested IF Statements, Constant Condition Problems (6/9/94)
• NEW: How to Avoid _parent Problems (6/28/94)
_____________________________________________________________________________
NEW: NewtonScript Object Sizes (6/30/94)
Generic
The Newtonscript Objects are the objects that either reside in the read-write memory,  pseudo-ROM memory or inside the package or ROM. These objects are aligned to 8-byte boundaries. This alignment causes a very small amount of fragmentation (usually under 2%) so this issue could be ignored.
Immediates
The Newton Object System has four built-in primitive classes that describe an object's basic type: Immediates, binaries, arrays and frames. In the case of an Immediates (integers, character, boolean and so on)  we are dealing with a 30+2 bit object.
In the case of binaries, arrays and frames we are also dealing with objects containing a so called Object Header.
Object Header
Every object has a 12-byte header that contains information concerning size, flags, class, lock count and so on. This information is implementation specific.
Strings
A string object contains a 12 byte header plus the Unicode strings plus a null termination character. Note that Unicode characters are two-byte values. Here's an example:
"Hello World!"
This string contains 12 characters, in other words it has 24  bytes. In addition we have a null termination character (24  + 2 bytes) and an object header  (24 + 2 + 12 bytes), all in all the object is 38 bytes big. Note that we have not taken into account any possible savings if the string was compressed (using the NTK compression flags).
Binary Objects
A binary object contains  a 12 byte header plus the size of the actual data.
Array Objects
Array objects have an object header (12 bytes) and additional four bytes per element. In addition you need to calculate the amount of data stored in the arrays as well (references) if you want to calculate the total amount.
Here's an example:
["Hello World!", "foo"]
We have a header (12 bytes) plus four bytes per element (12  + (2 * 4)  bytes). In addition we have string objects that we refer to  (12 + (2*4) + 38 + 20 bytes), all in all 78 bytes. Again we have not taken into account savings concerning compression. Note that the string objects could be referred by other arrays and frames as well, so if we want to take this into account we should make sure the string is counted only once per package.
Frame Objects
We have two kinds of frames, frames that don't have a shared map object, and frames who do have a shared map object. We take the simple case first (no shared map object).
An array object map is an array of symbol pointers and one additional slot. The actual frame is two arrays, one contains the slot names, and the other contains the actual slot entry.
The map is 16 bytes, if we add the object header to this the basic header size of a frame is 28 bytes.  If we want to add the size taken by slot entries we multiply N slots with 8 (two array entries). Here's an example:
{Slot1: 42, Slot2: "hello"}
We have a header of 28 bytes, in addition we have two slots (28 + (2 * 8)), all in all  48 bytes. Once again we didn't calculate the actual slot entry objects.
In the case of a frame with a shared map multiple similar frames (look the same) could share the one and only map. This will save space, reducing the marginal overhead per frame to the same as an array with the same amount of slots. In addition we need to take into account the amortized map size that multiple frames share. In other words the magic formula this time is 12 bytes for the header plus  4 times the amount of slots plus the amortized map size.
Here's an example of a frame with a shared map:
{Slot1: 42, Slot2: "hello"}
We have a header of 12 bytes, in addition we have two slots (2 * 4), and additional 16 bytes for the size of a map with no slots, all in all 36 bytes. We should also take into account the shared map, in the worst case there's only one of these frame objects, in other words we have additional 16 bytes.
When do we create objects with a shared map?
1. When we clone the system will make sure that the cloned object uses the same map. A trick to make use of this is to create a common template frame, and when we need to create additional frames we clone this template frame over and over.
2. The system will make sure that the frame uses a shared map if the frame is created by a a frame constructor expression in most cases a function that returns a frame. This is the reason we use RelBounds when we create the viewBounds frame, in other words there's just one single viewBounds map in the system, and it's stored inside the ROM.
Note again that these figures are for objects in their runtime state, ready for fast access. Objects in transit or in storage (packages) are compressed into smaller stream formats. These figures are neither true for flattened objects that are sent over a comms endpoint, neither true for objects stored in soups.
Symbols
Asymbol is a frame with two slots, one pointing to a string containing the name, the other pointing to the next symbol in an internal  hash table.  Symbols share one map, so each symbol occupies 12+2*4 = 20 (round to 24) bytes for the frame and 12+length (rounded) bytes for the name, for a total of 36+length bytes.
A symbol is a binary object that contains a four-byte hash value and the name is a null terminated ASCII character . Each symbol is 12 (header) + 4 (hash value_) + length of object + 1 bytes (null termination ASCII char).
PLAY CATCH - NEWTONSCRIPT EXCEPTIONS
(9/15/93) (Obsoleted by NS Guide 1.0 final docs)
Introduction
The NewtonScript exception system provides a structured way for a module to report a failure to another module.  It communicates the type of the failure, and allows (optionally) transmission of data that may explain the reason for the failure.  The NewtonScript implemention uses the exception system to report errors (for example, errors in an application, failures due to lack of resources, or internal errors).  Developers can use the exception system to communicate errors between different modules in an application.
Basic Syntax
The Exception handling is based on a try block, and if an exception is thrown from somewhere, the code should catch this with a special onException block.
Try Statements
The general format of the try statement is:
try
    <statement list>
onexception <exception symbol> do
    <statement>
onexception <exception symbol> do
    <statement>
...
An example of this might be:
try
begin
    // create entries and store them to soups
end
onexception |ext.ex.store.err| do
begin
    // problems with the store, most likely not enough memory
    // do something
end
The <exception symbol>s  must be single part exception symbols. Details about exception symbols — that is,  what multiple parts mean —  are discussed below.
One or more onexception clauses are allowed. The try statement executes <statement list>. If no exceptions are thrown in the process, then the value of the try statement is the value of the last statement in <statement list> and the onexception clauses are never executed.
If during execution of <statement list> an exception is thrown, then the execution of <statement list> stops and control is transferred to one of the onexception clauses. When an exception, X, is raised, the onexception clauses of the try statement are examined in order. The first clause whose <exception symbol> is a prefix of any of X's parts is executed and its <statement> value becomes the value of the try statement.
If no onexception clause matches the exception, then the exception is passed to the next enclosing try statement for processing. In a Newton application, the exception will ultimately be handled by the view system (putting up an error dialog box) if your application doesn't catch it.
NOTE:  It is important that the search for a matching onexception clause uses dynamic scoping, not lexical scoping.
Since all exceptions have an evt.ex part, an exception clause with evt.ex as its symbol will catch any exception. (See the following section for a description of "parts".) If your try statement has an evt.ex clause,  it should be last, since onexception clauses occuring after it will never be executed. In general, you should order your onexception clauses from most specific to least specific.
Exception Symbols
Exceptions have names which are symbols.  These symbols have a particular format which must be adhered to.  An exception name consists of one or more parts separated by semi-colons.  Each part is a structured name beginning with evt.ex.
A  few facts about exception symbols:
    • They can have as many as 127 characters.
    • They can contain periods, so the symbols must be enclosed in vertical bars (|'s)
    • They can have multiple parts, separated by semi-colons.
    • They must have a part starting with evt.ex.
The simplest possible exception symbol is |evt.ex|. An example of an exception symbol with two parts would be '|evt.ex;type.ref|.  Some more examples: '|evt.ex.div0|, '|evt.ex.fr.intrp;type.ref.frame|.
Exception Frames
Associated with every exception is an exception frame. When handling an exception you can get this frame using the global function, CurrentException(). An exception frame always has a name slot which contains the exception symbol. It will contain one other slot whose name and contents depend on the type of exception as follows: (this info is summarized on the NS Quick Ref Card)
• if  type.ref is a prefix in the exception symbol, then the other slot will be called data and can contain anything.
|evt.ex;type.ref|: {name: <string>, data: <frame>}
Ex: {name: "the llama exception", data : {type: 'inka, size: 42, weight: 177}}
• if evt.ex.msg is a prefix in the exception symbol, then the other slot will be called message and contain a string
|evt.ex.msg|: {name: <string>, message: <string>}
Ex: {name: "Ho ho exception", message: "You have a serious problem, mate"}
• otherwise, the other slot will be called error and will contain an integer (error code)
|evt.ex|: {name: <string>, error: <integer>}
Ex: {:name: "Hi Ho exception", error: -48666}
Here are examples of exception frames from real life:
• Example A,  division by zero:
{name: |evt.ex.div0|, error: 1764744}
If you want to catch division by zero errors, here's the trick:
try
    5/0
onexception |evt.ex| do
    CurrentException();
• Example B, undefined variable:
{name: |evt.ex.fr.interp; type.ref.frame|, data: {error:-48807, symbol: foo}}
How to Raise Gentle Exceptions
You can throw an exception using the global function, Throw(<exception symbol>, <exception data>). The value you pass for <exception data> is put into the "other" slot of the exception frame. Make sure it is the correct type (as per the above rules) or your  call to Throw will raise another exception.
If the code block has more than one try statement in effect at one time, you can pass control to the next enclosing try statement using the Rethrow  function.
Here are examples of the three different ways to create and throw exceptions. Note that you need to send an exception symbol ('):
Throw('|evt.ex.foo|, 99);
Throw('|evt.ex.msg|, "string");
Throw('|evt.ex;type.ref.something|, ["a", "b", "c"])
Default Exception Handling
Unfortunately, there is currently no general way for your application to specify a default exception handler, for example, viewExceptionScript. This means you need to use try statements wherever you want to catch exceptions.
Examples
Here's some code  to test out the exception system. This tries various cases and is designed to print no output, assuming  the exception system works as advertised. However,  the NTK Inspector prints out every exception that is thrown, whether it's handled or not. Expect to see output; however, none of thePrint("*error?*) statements should execute.
//simple cases & a nested block
try
    begin

        try
            Throw('|evt.ex;type.ref;foo|,"dsafsda");
            Print("*error*1");
        onexception |foo| do
            begin
                //Exception handled quietly
             end;

        try
            Throw('|evt.ex;type.ref;foo|,"dsafsda");
            Print("*error*2");
        onexception |type.ref| do
            begin
                //Exception handled quietly
             end;

      //outer block should catch this one
        Throw('|evt.ex.foobar|,42);

      Print("*error*3");
    end
onexception |evt.ex| do
    if CurrentException().error <> 42 then
        begin
            Print("*error*4");
            Print(CurrentException())
        end;
//try out rethrow()
try
    begin

        try
            Throw('|evt.ex|,42);
            Print("*error*5");
        onexception |evt.ex| do
            begin
         //outer block should catch this one
                Rethrow();
             end;

    Print("*error*6");

    end
onexception |evt.ex| do
    if CurrentException().error <> 42 then
        begin
            Print("*error*7");
            Print(CurrentException())
        end;
//try it out with fn calls
try
    begin

        call func()
            begin
                try
                    call func(esym) Throw(esym,42) with ('|evt.ex|);
                    Print("*error*8");
                onexception |type.ref| do
                    begin
                 //outer block should catch this one
                        Rethrow();
                     end;
            end
        with ();

        Print("*error*9");

    end
onexception |evt.ex| do
    if CurrentException().error <> 42 then
        begin
            Print("*error*10");
            Print(CurrentException())
        end;
Print("no news, is good news");
_____________________________________________________________________________
NewtonScript Q&As
    ___________________________________________
Garbage Collection (10/15/93) (Obsoleted by NS Guide 1.0 Final Documentation)
In NewtonScript, the run-time module, not the programmer, is responsible for allocating storage for objects and for reclaiming the storage of objects that are no longer used. Garbage collection is carried out by the basic object system, so it’s not technically NewtonScript that does it.  The storage taken up by an object will be freed sometime after the last reference to that object goes away.
One of the many benefits of garbage collection is that the programmer has to think about freeing objects only  in a small number of important places, as opposed to dealing with the constant background worry that objects must be freed. Wth automatic garbage collection you only need to consider disposing objects in rare cases.
One place where you should think about it is when you close an application; here you want to free as much storage as possible. You do this by either removing slots  or by setting slots to nil in the application's context frame.  Setting the value of all slots and variables referring to a particular object to nil allows the Garbage Collector to destroy the object.
Within the Newton operating system, automatic garbage collection is triggered every time the system runs out of memory. There's not really any reason to invoke garbage collection manually. However, if you must do so, you can call the global NewtonScript function GC. Consult the Newton Programmer’s Guide to find out more about the GC function.
    ___________________________________________
Order of Slots in Frames (9/15/93)
Q:     The description of the foreach function in the manual might be taken as a hint that slots in frames are ordered.  Does slot or array order imply anything about layout of data in memory (as with C structs?)
A:     Slots are not ordered, nor have we seen any performance gains from ordering slots for particular sequences or search criteria. Don’t count on their being in any particular order, nor on data structures in memory being ordered with any regard to the placement of slots (as in the ANSI Common LISP object extension CLOS).
Q:    Where is a newly-defined slot placed in a frame? at the end?
A:    Because slots are unordered, the location of a new slot cannot be predetermined.
    ___________________________________________
Structured Literals (9/15/93)
Q:     Is it really dangerous to assign a string literal to a variable, as in the following example?
    s := "abc";
A:     That depends on what you're going to do with s. If you're
    going to modify it, then yes, it's dangerous. In that case, you
    should use
    s := Clone("abc");
    In general you should treat string literals in NewtonScript
    as read-only (just as you should in ANSI C). String literals might
    reside in read-only memory or share storage with other literals.
    The same warning applies to quoted array and frame literals, as in the following example:
     '[1,2,3] or '{one: 1, two: 2, three: 3}
    Here are some rules regarding string literals and quoted array/frame literals:
    - Treat them as read only. Use clones when necessary.

    - Realize that they always represent the same object.   In the example below,
    func foo() begin "abc"
    end;
     - always returns exactly the same string - not different,
    equivalent strings.
    - In your code, an unquoted array or frame literal will generate a
    new array or frame each time it is evaluated. So it’s acceptable for a
    function to return [1,2,3] or {one: 1,two: 2,three: 3} as long as
    they're not quoted.
    ___________________________________________
Passing Arguments (9/15/93)
Q:     Is NewtonScript call-by-reference or call-by-value?
A:     A seemingly simple question. The short answer is “call-by-value,” the litmus test being that
     func foo(x) x := 1;
    does not affect the argument passed to it. However, this is not meant to imply that NewtonScript functions can never make changes to their arguments. If the argument has structure—for example, if it’s an array, frame, or string—then changes to the internal structure are persistent. Consider the following code fragments:
     func foo(x) x[0] := 1;
    // changes the 1st element of array arguments

    func foo(x) x.slot1 := 1;
    // changes the slot1 slot of frame arguments
    Depending on what you’re used to, this example might be confusing because the concepts of call-by-reference, call-by-value are mixed, and copying arguments are intertwined (and often misunderstood.) The following discussion of this terminology with respect to other languages may help clarify the differences.
    Pascal - Supports both call-by-reference (VAR parameters) or call-by-value (the default). When array or record arguments use call-by-value, copies of the arrays/records are made and passed in. To Pascal programmers, NewtonScript may seem to pass arrays and frames as VAR parameters.
    C - Only supports call-by-value. Struct (not struct*) arguments are
    passed as values; that is, a copy of the struct is passed. However, array arguments pass in the address of the first element of the array. Thus, C programmers will find the array arguments to be treated normally.
    LISP - Only supports call-by-value. Copies are not made of structured
    arguments (lists, structures, arrays, objects,...) Argument passing in Newton Script works just like it does in LISP.
    ________________________________________
Slot (Variable) Lookup (9/15/93)
Q:     What differences are there among the various ways to access a slot?
A:    The means by which you access a slot specifies the search path and inheritance mechanisms used to locate it. Each of the five ways to access a slot is described below.
    •Specifying the slot name only
    If you specify only the name of the slot, as in the example
    theSlot
    the search begins in the current function frame with lexically-visible variables, followed by slot names. In other words, if the currently-executing function has a local variable named theSlot, it is found before a local variable named theSlot in the enclosing function, and so on. Similarly, any of those variables are found (in scope order) before an actual slot named theSlot is found. If a variable named theSlot is not found, global variables are searched next. If a global variable is not found, the current receiver is searched for a slot named theSlot.
    If the slot is not found in the receiver of the message, the remaining frames are searched in order of prototype and parent inheritance. An exception is thrown if you try to access a slot that can't be found.  If you do an assignment operation using an undeclared slot, the slot is created if you place the self. prefix in front of the slot name; if you do the operation without the self. prefix you will get a local variable.
    •Using the dot (.) operator
    If you use the dot operator to specify the frame and the slot,  as in the example
    myframe.myslot
    the search begins in the specified frame.  If the slot is not found in the specified frame, the remaining frames are searched in order of prototype inheritance.  Parent inheritance paths are not searched. If the slot does not exist, the system returns NIL.

    •Using the GetSlot function
    If you call
    GetSlot(frame, slot)
    only the specified frame is searched for the specified slot. Inheritance paths are not searched.
    •Using the GetVariable function
    If you call
    GetVariable(frame, slot)
    the search begins in the specified frame.  If the slot is not found in the current frame, the remaining frames are searched in order of prototype and parent inheritance.
    •GetVar will be removed from the language
You can usually simulate GetVar using GetVariable(self,slot). The difference will be that local variables will not be found - only slots.
If you use GetVar you may find that is not available in future products, in which case your code will throw an exception; or  GetVar may work differently not finding local variables anymore, in which case your code may subtly break. DTS advises against using GetVar.
    ___________________________________________
Testing the Existence of a Slot (Variable) (9/15/93) (Obsoleted by NS 1.0 Final Documentation).
Q:     What differences are there among the various ways to determine whether a slot exists in a frame?
A:    The means by which you test for a slot's existence specifies the search path and kinds of inheritance used to discover it. The following examples describe three ways to discover the existence of a slot in a frame.
    • Using the exists operator
    The exists operator follows the same rules as the expression to which it is applied. For example, if you use this operator to test a slot access expression, as in the example
    myframe.myslot exists
    the search begins in the specified frame.  If the slot is not found in the current frame, the remaining frames are searched in order of prototype inheritance only. Parent inheritance paths are not searched.
    However, when using the exists operator to check whether an identifier exists, as in the example
    myvar exists
    both prototype and parent inheritance paths are searched.
    • Using the HasSlot function
    If you call
    HasSlot(frame, slot)
    only the specified frame is searched for the specified slot. Inheritance paths are not searched.
    • Using the HasVariable function
    If you call
    HasVariable(frame, slot)
    the search begins in the current frame. If the slot is not found in the current frame, the remaining frames are searched in order of prototype and parent inheritance.
    ___________________________________________
Calling Methods Out Of Slot Context (9/15/93) (Obsoleted by NS Guide 1.0 Final Documentation)
Q:     I'm trying to pull a method out of a slot and call it. Unfortunately, the functions apply and call both seem to set self to {}. Is there another way?
A:     The global function Perform(frame, message, paramaterArray) does what you want, except that the method needs to be in a slot in the current frame if you really want to preserve the value of self.
    ___________________________________________
Inherited (10/13/93) (Obsoleted by NS Guide 1.0 Final Documentation)
Q:     What is the function of "inherited:" and "inherited:?"
A:  In NewtonScript, the inherited:X() message send specifies a NewtonScript function call on the function X, where X is found UP the inheritance chain starting from the caller's _proto. In other words, lookup for that method ONLY starts up the caller's _proto chain, NOT in  "self" (the currently executing frame). The conditional message send (:?), with inherited specified, operates almost exactly the same  except that no error results if the given method (function) is NOT found. The conditional message send (:?), with inherited specified, is helpful in complex heirarchies because you can use it without  worrying about whether any such method was ever implemented higher up in the inheritance chain.
    ___________________________________________
Deeply (foreach deeply in...) (10/13/93)(Obsoleted by NS Guide 1.0 Final Documentation)

Q:     What is the difference between "foreach" and "foreach deeply in"?
A:  'Deeply' specifies that only the slots/elements of the current frame/array are listed, except that if passed a frame, slots of ancestors up the _proto chain are considered elements of the current frame.
    Here is some Inspector code to illustrate the difference between the two:
    //oo DEFINITIONS
    normallist := func (param)
       begin
          local tempItem;
          foreach tempItem in param
                  collect tempItem;
       end;
    deeplylist := func (param)
       begin
          local tempItem;
          foreach tempItem deeply in param
                  collect tempItem;
       end;
    //oo SAMPLE DATA
    x := {one: 1, two: 2, three: 3};
    y:= {four: 4, five: 5, combo: x};
    z:= {six: 6, _proto: y};
    complex := {a: "first string", b: ["array1", "array2",
        {_proto: x}], c: 3.1415926};

    //oo TESTS
    :normallist(x)          // same
    #4413441  [1, 2, 3]
    :deeplylist(x)
    #44137D9  [1, 2, 3]
    :normallist(y)          // same
    #4413A11  [4,
           5,
           {One: 1,
            two: 2,
            three: 3}]
    :deeplylist(y)
    #4413C49  [4,
           5,
           {One: 1,
            two: 2,
            three: 3}]
                        // For z, the answer is different.
                        // the deeply version travels proto chains!
    :normallist(z)
    #4416E29  [6,
           {four: 4,
            five: 5,
            combo: {#4415D79}}]
    :deeplylist(z)
    #4416FE1  [6,
           4,
           5,
           {One: 1,
            two: 2,
            three: 3}]
                 // for this complex frame, the answers are the same
                 // because there is no _proto slot in the *MAIN* frame
                 // hence there is nowhere to go deeply into.
    :normallist(complex)
    #4418741  ["first string",
           ["array1", "array2", {#44183B9}],
           3.14159]
    :deeplylist(complex)
    #4418AC1  ["first string",
           ["array1", "array2", {#44183B9}],
           3.14159]
    ___________________________________________
Compile Function (10/9/93) (Obsoleted by NS Guide 1.0 Final Documentation)
Q:     I need the ability to download the validtest and endtest functions to the Newton for searches.  I do not see how I can convert the incoming textual representation of the function to code to execute.  How could I do this?
A:    You could use the special compile function in NewtonScript. Here's an example of how to use compile:
    begin
          local x;
          // Set x to be a function that returns the new function.
          x := Compile("Print(\"Hello\")");
            // Now call the actual compiled function.
          call x with ();
          // At this point, "Hello" will have been printed to the inspector...
    end;
    Note that compile returns a function taking no arguments whose body is the string passed to compile.  If you need to create a function taking arguments, you can create a function with Compile whose return value is a function that takes arguments, like this:
f := call Compile("func(x) x*x") with ();
call f with (10);  // prints 100.
    ___________________________________________
Function Definitions (10/9/93)
Q:    Is it "safer" to use a return statement at the end of a function or is it just a style issue?
A:    All functions return the last value in the function body. This means that you have a choice of explicitly writing a return statement, or assuming that the code reader knows that the last statement is automatically returned.
    One might argue that a return statement should always be used. However there are cases where the code looks prettier with no return statement, and the return statement does generate code. Compare the following two examples:
    begin
        ...
        if expr then "" else text
    end
    begin
        if expr then
            return ""
        else
            return text
    end
    Additionally, in the current NewtonScript compiler, an extra byte or two is used for the return statement, but in most cases it will make no apparent difference in speed.
    ___________________________________________
Closures and Perform (10/9/93) (Obsoleted by NS Guide 1.0 Final Documentation)
Q:     The NewtonScript manual indicates that the receiver during a call is the receiver that made the call. For example, the code

        a := {
        id: "a",
        foo: func() Print(id),
    };

    b := {
        id: "b",
        bar: func() call a.foo with (),
    };

    b:bar();

    should print "b".

    When I run this in an Inspector, however, it appears that the receiver during the execution of foo() is the top level frame in which a (and b) is defined.  How is the receiver actually determined?  Is it always the top level of the Inspector?

A:     What you really create is a closure, which is the executable code bound up with the dynamic and lexical environments at the time the function was created.  That is, whatever self evaluated to when the function was compiled is what it will evaluate to when it's called.
    The Perform  call, or message-passing does change the closure's dynamic environment (self) to the frame that was specified by the message pass or Perform call.
    To do what you seem to be attempting, you could try this:
    a := {
        id: "a",
       foo: func() Print(id)};
    b := {
        id: "b",
        bar: func() begin self.temp := a.foo; :temp() end};
    b:bar();
    Instead of :temp() above, you could have used Perform(self, 'temp, []);  Perform is handy when you don't know at compile time which message you need to pass. For example, you can write Perform(self, jumpTable[i], []); where jumpTable contains an array of symbols representing methods. Perform takes a frame, a message and an array of message parameters.
    ___________________________________________
Symbol Hacking (11/11/93) (Obsoleted by NS Guide 1.0 Final Documentation)
Q:    I would like to be able to build frames dynamically and have my application create the name of the slot in the frame dynamically as well.  For instance, something like this:
    MyFrame:= {}; tSlotName := "Slot_1";

    At this point is there a way to then create this ?:
    MyFrame.Slot_1
A:    There is a function called Intern, that takes a string and makes a symbol. There is also a mechanism called path expressions (see the NewtonScript manual), that allows you to specify an expression or variable to evaluate, in order to get the slot name. You can use these things to access the slots you want:
    MyFrame := {x: 4} ;            // MyFrame -->{x: 4}
    theXSlotString := "x" ;
    MyFrame.(Intern(theXSlotString)) := 6
                         // MyFrame --> {x: 6}
    tSlotName := "Slot_1" ;     // the following code creats a
                        // slot called Slot_1 in MyFrame and
                        // assigns it the number 7.     MyFrame.(Intern(tSlotName)) := 7 ;
                        // MyFrame --? {x: 6, Slot_1: 7}
Q:    Is there a way to look for a slot programmatically starting with a slot name string?
A:    Here's the code which can do this:
    if MyFrame.(Intern(slotToFind)) exists then
          x := MyFrame.(Intern(slotToFind)) ;  // use the slot

    ___________________________________________
Literals and run time (11/11/93)
Q:    Is the literals slot really needed during run time? I noticed that I could figure out quite a lot about how my functions work from the literals used (examining the literals slot). I would rather not make it easy for others to reverse engineer certain routines.
A:    The literals slot is indeed needed during run time (in the current implementation of NewtonScript) The interpreter is using it at run time. Here's an example:
    f := func() "abc";
    #4409CB9  <CodeBlock, 0 args #4409CB9>
    f.literals
    #4409B61  [literals: "abc"]
    f.literals[0] := {foo: 'bar}
    #440A1D1  {foo: bar}
    call f with ()
    #440A1D1  {foo: bar}
    Don't assume anything about the implementation of the literals slot in future Newton system software.
    ___________________________________________
Missing Semicolons cause Weird Errors (12/11/93) (Obsoleted by NS Guide 1.0 Final Documentation)
As with Pascal, semicolons are statement separators, not terminators. If you forget to add a semicolon at the end of the Newtonscript statement, the interpreter will try to interpret a larger statement than intended, causing strange error reports.
The following is an example of such a case.
You are getting an "expected array, frame, or binary but got 8" exception because you
wrote the following code:
     :Emit(dest, 'subprim, "Send", [t2, t1, Length(node.r3)])
     :PopTemp('ref);
Note the missing semicolon on the first line.  This is parsed as
     (:Emit(blah blah)):PopTemp('ref);
The :Emit call resulted in an 8, which was used as the receiver for the PopTemp message.  This was NOT what the programmer intended.
There are two habits that would have prevented this error. You might want to consider them as part of your personal coding style, though neither of them is extremely important since this error is pretty rare.
        - Always use "self:foo()" instead of ":foo()".
        - Always put a semicolon at the end of a statement, even  when you don't need to.
    ___________________________________________
Classical OOP programming withNewtonScript (12/17/93)
(Obsoleted by NS Guide 1.0 Final Documentation)

Q:  I would like to see the ability to use more of a C++ approach, where I could inherit code —     not necessarily user-interface (view) oriented code — with functionality like templates.

A: You can easily simulate most aspects of traditional class-instance OO programming (as in Smalltalk or C++) using NewtonScript.  There aren't any specific features in NTK 1.0 to support this, but you can do it without too much trouble, using the Project Data window.
    The basic idea is to use _parent inheritance to provide the link between "instances" and "classes".  You define a frame in the Project Data to hold the methods (this is the "class"), and you construct "instances" whose slots are the "instance variables" (or "members" if you prefer C++).  Quotes will continue to be used around these words to emphasize that there is no built-in concept of a class in NewtonScript; we are using the prototype-based inheritance system to simulate class-based inheritance.
    Suppose we want to create a "class" to represent a stack.  We will represent the stack as an array.  Each "instance" needs to store the array and the index of the top element of the stack, so an "instance" will look like this:
    { _parent: ...,                 // pointer to the "class"
      items: [...],                 // array of items
      topIndex: 2 }                 // index of top item
    The "class" contains the methods, like so:
Stack :=
        { Push:     func (item) begin
                            topIndex := topIndex + 1;
                            items[topIndex] := item;
                            self
                        end,

              Pop:      func () begin
                            if :IsEmpty() then
                                NIL
                            else begin
                                local item := items[topIndex];
                                items[topIndex] := NIL;
                                topIndex := topIndex - 1;
                                item
                            end
                        end,

              IsEmpty:  func ()
                            topIndex = -1,
              Clone:    func () begin
                            local new := Clone(self);
                            new.items := Clone(new.items);
                            new
                        end,
              New:      func ()
                            {_parent: self,
                             items: Array(10, NIL),
                             topIndex: -1}
            }
    Obviously, this ignores such niceties as stretching the array and signalling error conditions, for the sake of clarity.
    To get a new Stack "instance", you send the New message to the "class":
    s := Stack:New();
    Now you can send messages to s to get work done:
    s:Push('a)
    x := s:Pop()
    if s:IsEmpty() then ...
    s2 := s:Clone()
    // etc.
    You can put "class variables" and "class methods" in the "class" if you want; they're all the same thing in this model, just slots of the "class". The New method is an example.  Note that you can get a new instance from an old instance (i.e., s:New()) because of this unity.
    Those who have been paying attention to the Listener output may already have noticed this method of programming, because it is used by soups, stores, and cursors.  (But you should assume that anything undocumented you notice in the Inspector may be changed in the next ROM.)
    To use this technique in NTK, you can put the "class" in the Project Data window. To access it from your code, you'll need to put a slot that refers to it in your main view (or lower down if you don't need the class throughout your application).  You can just add a slot called "Stack" whose value is "Stack", or if you prefer, you can use distinct names (for example, call it "StackClassFrame" in Project Data).
    Here's an example, in NTK text-export form.  This does not include the project data section, because it looks just like the "Stack :=" section above.  This is just an application with a button that prints "30" in a complicated way using a stack object.
main :=
   {title: "xxx",
    viewBounds: {left: -1, top: 0, right: 236, bottom: 333},
    Stack: Stack,
    _proto: protoapp,
   };
_view000 := /* child of main */
   {text: "Button",
    buttonClickScript:
      func()
      begin
         local s := Stack:New();
         s:Push(10);
         s:Push(20);
         Print(s:Pop() + s:Pop())
      end,
    viewBounds: {left: 74, top: 74, right: 154, bottom: 106},
    _proto: prototextbutton
   };
    You can use an extended form of this technique to put an object-oriented interface on soup entries.  "Wrap" the soup entry in an "instance" frame like the one above by pointing a slot of the "instance" to the soup entry.  You can have "class methods" to do queries and return these "instances". You can also have  "instance methods" to change, validate, undo, flush, and so on.  You can also choose _proto as the slot that points to the soup entry, so you inherit the entry's slots--but remember that slot assignments will go into the "instance", not the entry.
    If you're intrigued by all this, see  the various papers on the language "Self", by Ungar, Chambers, and others at Stanford (now at SunSoft).  Many aspects of NewtonScript were inspired by Self. The postscript files are available via ftp on Internet from self.stanford.edu.
    ___________________________________________
Only 7-Bit ASCII In NewtonScript Symbols (1/26/94) (Obsoleted by NS Guide 1.0 Final Documentation)
Q:    My frame has some slot symbols that contain accent and special letters. For example:
    f := {|à|:"help me please", |é|:"Thanks in advance", ...,...}
    My program received a letter from ProtoInputLine and turned it into a symbol. I have tried many different ways to do this but I could not convert it into a symbol.
A:    The basic problem is you can only use 7-bit ascii in symbols.
    ___________________________________________
Nested IF Statements, Constant Condition Problems (6/9/94)
Q:     I have found a mysterious problem with Scripts containing  nested IFs. In some cases like the following example they are executed in an abnormal way.
    The true conditions in the real code are constants defined in the project data file with values true or nil. These are used for conditional compiling.
    protoApp.viewSetupDoneScript : FUNC ()
    begin
     if TRUE then
        begin
         if TRUE then
            begin
             if TRUE then
            begin
                 if TRUE then
                    begin
                      Print ("Idlescript1");
                   end
            end
        end
        end;
      Print ("Idlescript2");
    end
    There should be only two prints. In fact there are five prints in the following
    manner:
    "Idlescript1"
    "Idlescript1"
    "Idlescript1"
    "Idlescript1"
    "Idlescript2"
    If I define Boolean slots with value truein the base view, and if I use those slots as conditions, the code works like it should. Why can nested IFs with constant conditions work like a loop?
A:     This is a bug in the compiler's handling of IF statements with constant conditions.  The bug occurs only if the result of the IF statement is not used.  For example,
    func () begin
        if TRUE then
            if TRUE then
                Print(1);
        Print(2);
    end
    will trigger the bug, but
    func () begin
        local x := if TRUE then
                       if TRUE then
                           Print(1);
        Print(2);
    end
    will not.
    The workaround is to use the result of the if statement.  You don't really want to keep the result around, so the above example is not recommended .  The simplest  workaround is probably the following:
    func () begin
        (
            if TRUE then
                if TRUE then
                    Print(1);
        ) and TRUE;
        Print(2);
    end
    This works because the NTK 1.0.1 compiler does not throw away the "and true" part, but the result of the "if" is dropped immediately.
    ___________________________________________
NEW: How to Avoid _parent Problems (6/28/94)
Q:    I read somewhere that developers should never access a view _parent slot directly? Are there any cases when it is safe to access the _parent slot?
A:    In most cases, you should use the :Parent() view method to determine a parent view. However, there are some cases when you want to access the _parent slot of a view directly.  The situation which is bad is to use _parent as a simple variable because results will vary depending on implementation of the current function. Some guidelines:
             _parent    is bad
         view:Parent()  is OK
        self._parent    is OK (and should be the same as :Parent())
        view._parent    is OK (and should be the same as view:Parent())
_____________________________________________
î◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,Times
$°dONLNd)âM
ü+;8NEWTONSCRIPT°dONLNd
Mãq
ù+$PROGRAMMING°dONLNdq∞ï
x+%$LANGUAGE,    Helvetica

°dONLNd"ï~°
ò(Ωú<© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved
°dONLNd_™*º
Ï(◊H-_____________________________________________
°dONLNdèÿNıÊ+$6Introduction

°dONLNdú
N

˚*,[This document addresses NewtonScript Programming Language  issues that are not available in°dONLNd¯
N
)
Ò*_the currently printed documentation . Please note that this information is subject to change as°dONLNd
X
)N
5
f*9the Newton technology and development environment evolve.
°dONLNd
í
ON
_Ï*)TABLE OF CONTENTS:,    Geneva

°dONLNd
•
_N
l
2**• NEW: NewtonScript Object Sizes (6/30/94)°dONLNd
–
kN
x
ñ*A• Play Catch - NewtonScript Exceptions (Obsoleted by NS Guide 1.0°dONLNd
wN
Ñ√*    Final Documentation)
°dONLNd+
ìN
£“*NewtonScript Q&As

°dONLNd=
£N
∞
Ê*O• Garbage Collection (10/15/93) (obsoleted by NS Guide 1.0 Final Documentation)°dONLNdç
ØN
º
*$• Order of Slots in Frames (9/15/93)°dONLNd≥
ªN
»Ù*• Structured Literals (9/15/93)°dONLNd‘
«N
‘Ò*• Passing Arguments (9/15/93)°dONLNdÛ
”N
‡
*"• Slot (Variable) Lookup (9/15/93)°dONLNd
flN
Ï
‚*Q• Testing the Existence of a Slot (Variable) (9/15/93) (Obsoleted by NS 1.0 Final°dONLNdi
ÎN
¯§*   Documentation)°dONLNd{
˜N
‡*P• Calling Methods Out Of Slot Context (9/15/93) (Obsoleted by NS Guide 1.0 Final°dONLNdÕN§*   Documentation)°dONLNdflN
ª*F• Inherited (10/13/93) (Obsoleted by NS Guide 1.0 Final Documentation)°dONLNd&N(
«*J• Deeply (foreach deeply in...) (10/13/93)(Obsoleted by NS Guide 1.0 Final°dONLNdr'N4§*   Documentation)°dONLNdÑ3N@
€*L• Compile Function (10/9/93) (Obsoleted by NS Guide 1.0 Final Documentation)°dONLNd—?NL¯* • Function Definitions (10/9/93)°dONLNdÚKNX
Ò*P• Closures and Perform (10/9/93) (Obsoleted by NS Guide 1.0 Final Documentation)°dONLNdCWNd
€*K• Symbol Hacking (11/11/93) (Obsoleted by NS Guide 1.0 Final Documentation)°dONLNdècNp
*!• Literals and Runtime (11/11/93)°dONLNd±oN|
Â*M• Missing SemiColons cause Weird Errors (12/11/93) (Obsoleted by NS Guide 1.0°dONLNd{Nà¿*   Final Documentation)°dONLNdáNî
˛*R• Classical OOP programming ala NewtonScript (12/17/93) (Obsoleted by NS Guide 1.0°dONLNdlìN†¿*   Final Documentation)
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
1ˇ∞◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,    Geneva

°dONLNd)N6
Ï*'O• Only 7-Bit ASCII In NewtonScript Symbols (1/26/94) (Obsoleted by NS Guide 1.0°dONLNdQ5NB¿*   Final Documentation)°dONLNdiANN
Ñ*<• Nested IF Statements, Constant Condition Problems (6/9/94)°dONLNd¶MNZ
K*.• NEW: How to Avoid _parent Problems (6/28/94),    Monaco
    °dONLNd’Å*å
¯(©HM_____________________________________________________________________________
°dONLNd
$öN™
\+$(NEW: NewtonScript Object Sizes (6/30/94),    Helvetica°dONLNd
M∏N«Ä*Generic

°dONLNd
UΔN“
ı*]The Newtonscript Objects are the objects that either reside in the read-write memory,  pseudo°dONLNd
≤Δ
ı“
˘(Ó
-°dONLNd
≥“Nfi
È(˙lXROM memory or inside the package or ROM. These objects are aligned to 8-byte boundaries.°dONLNdfiNÍ
Ï*[This alignment causes a very small amount of fragmentation (usually under 2%) so this issue°dONLNdhÍNˆô*could be ignored.
°dONLNd{
N
ò*(
Immediates

°dONLNdÜ
N
*
È*\The Newton Object System has four built-in primitive classes that describe an object's basic°dONLNd„
*N
6
—*Vtype: Immediates, binaries, arrays and frames. In the case of an Immediates (integers,°dONLNd:
6N
B
|*Echaracter, boolean and so on)  we are dealing with a 30+2 bit object.°dONLNdÇ
NN
Z
¸*bIn the case of binaries, arrays and frames we are also dealing with objects containing a so called°dONLNdÂ
ZN
fí*Object Header.
°dONLNdÙ
ÄN
è©*(
Object Header

°dONLNd
éN
ö
Ô*_Every object has a 12-byte header that contains information concerning size, flags, class, lock°dONLNdb
öN
¶
^*=count and so on. This information is implementation specific.
°dONLNd†
¿N
œz*(Strings

°dONLNd®
ŒN
⁄
ÿ*ZA string object contains a 12 byte header plus the Unicode strings plus a null termination°dONLNd
⁄N
Ê
æ*Ocharacter. Note that Unicode characters are two-byte values. Here's an example:,
Courier°dONLNdS
Ú¸
˛
P+Æ"Hello World!"°dONLNdbN
Ï(0l_This string contains 12 characters, in other words it has 24  bytes. In addition we have a null°dONLNd¬N 
˝*ftermination character (24  + 2 bytes) and an object header  (24 + 2 + 12 bytes), all in all the object°dONLNd) N,
ı*`is 38 bytes big. Note that we have not taken into account any possible savings if the string was°dONLNdä,N8
!*-compressed (using the NTK compression flags).
°dONLNd∏PN_©*&Binary Objects

°dONLNd«^Nj
ô*LA binary object contains  a 12 byte header plus the size of the actual data.
°dONLNdÑNì£*(
Array Objects

°dONLNd"íNû
÷*XArray objects have an object header (12 bytes) and additional four bytes per element. In
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
2ˇD◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd)N5
Ì*&^addition you need to calculate the amount of data stored in the arrays as well (references) if°dONLNd_5NAˇ*'you want to calculate the total amount.°dONLNdáMNY•*Here's an example:,
Courier°dONLNdöe·q
k+ì["Hello World!", "foo"]°dONLNd≤{Ná
È(£l^We have a header (12 bytes) plus four bytes per element (12  + (2 * 4)  bytes). In addition we°dONLNd
áNì
Á*ahave string objects that we refer to  (12 + (2*4) + 38 + 20 bytes), all in all 78 bytes. Again we°dONLNd
sìNü
˚*ahave not taken into account savings concerning compression. Note that the string objects could be°dONLNd
’üN´
*^referred by other arrays and frames as well, so if we want to take this into account we should°dONLNd4´N∑
>*6make sure the string is counted only once per package.,    Helvetica
°dONLNdkœNfi´*&
Frame Objects

°dONLNdy›NÈ
ı*ZWe have two kinds of frames, frames that don't have a shared map object, and frames who do°dONLNd‘ÈNı
µ*Ohave a shared map object. We take the simple case first (no shared map object).°dONLNd$

N


˜*_An array object map is an array of symbol pointers and one additional slot. The actual frame is°dONLNdÑ

N

»*Vtwo arrays, one contains the slot names, and the other contains the actual slot entry.°dONLNd€
%N
1
Ó*_The map is 16 bytes, if we add the object header to this the basic header size of a frame is 28°dONLNd;
1N
=
Ó*^bytes.  If we want to add the size taken by slot entries we multiply N slots with 8 (two array°dONLNdö
=N
IÕ*entries). Here's an example:°dONLNd∑
U’
a
w+á{Slot1: 42, Slot2: "hello"}°dONLNd”
kN
w
Ò(
ìlaWe have a header of 28 bytes, in addition we have two slots (28 + (2 * 8)), all in all  48 bytes.°dONLNd5
wN
É
Y*=Once again we didn't calculate the actual slot entry objects.°dONLNds
èN
õ
ı*\In the case of a frame with a shared map multiple similar frames (look the same) could share°dONLNd–
õN
ß
Ú*[the one and only map. This will save space, reducing the marginal overhead per frame to the°dONLNd,
ßN
≥
Ï*\same as an array with the same amount of slots. In addition we need to take into account the°dONLNdâ
≥N
ø
ˆ*\amortized map size that multiple frames share. In other words the magic formula this time is°dONLNdÊ
øN
À
À*V12 bytes for the header plus  4 times the amount of slots plus the amortized map size.°dONLNd=
◊N
„
.*/Here's an example of a frame with a shared map:°dONLNdm
Ô’
˚
w+á{Slot1: 42, Slot2: "hello"}°dONLNdâN
˚(-l`We have a header of 12 bytes, in addition we have two slots (2 * 4), and additional 16 bytes for°dONLNdÍN
¯*athe size of a map with no slots, all in all 36 bytes. We should also take into account the shared°dONLNdLN)
Ã*Vmap, in the worst case there's only one of these frame objects, in other words we have°dONLNd£)N5©*additional 16 bytes.°dONLNd∏ANM
!*,When do we create objects with a shared map?°dONLNdÂYNe
¸*_1. When we clone the system will make sure that the cloned object uses the same map. A trick to°dONLNd    EeNq
Ù*\make use of this is to create a common template frame, and when we need to create additional°dONLNd    ¢qN}
5*2frames we clone this template frame over and over.°dONLNd    ’âNï
Ó*\2. The system will make sure that the frame uses a shared map if the frame is created by a a
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
3ˇ
◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd)N5
ˆ*&aframe constructor expression in most cases a function that returns a frame. This is the reason we°dONLNdb5NA
Â*Yuse RelBounds when we create the viewBounds frame, in other words there's just one single°dONLNdºANM
k*=viewBounds map in the system, and it's stored inside the ROM.°dONLNd˙YNe
˚*dNote again that these figures are for objects in their runtime state, ready for fast access. Objects°dONLNd
_eNq
¸*ain transit or in storage (packages) are compressed into smaller stream formats. These figures are°dONLNd
¡qN}
Î*`neither true for flattened objects that are sent over a comms endpoint, neither true for objects°dONLNd"}Nâí*stored in soups.,    Helvetica
°dONLNd3£N≤Ñ*(Symbols

°dONLNd;±NΩ
‡*ZAsymbol is a frame with two slots, one pointing to a string containing the name, the other°dONLNdñΩN…
ı*^pointing to the next symbol in an internal  hash table.  Symbols share one map, so each symbol°dONLNdı…N’
Ê*\occupies 12+2*4 = 20 (round to 24) bytes for the frame and 12+length (rounded) bytes for the°dONLNdR’N·Ò*%name, for a total of 36+length bytes.°dONLNdxÌN˘
“*WA symbol is a binary object that contains a four-byte hash value and the name is a null°dONLNd–˘O

˘+
^terminated ASCII character . Each symbol is 12 (header) + 4 (hash value_) + length of object +°dONLNd/
O
˚*&1 bytes (null termination ASCII char).
°dONLNdV
$*
7
ò(
QH$PLAY CATCH - NEWTONSCRIPT EXCEPTIONS
°dONLNd{
7N
G
y+$0(9/15/93) (Obsoleted by NS Guide 1.0 final docs)
°dONLNd¨
^*
qâ(
ãHIntroduction

°dONLNdπ
qN
}
Ù+$\The NewtonScript exception system provides a structured way for a module to report a failure°dONLNd
}O
â
 +
Tto another module.  It communicates the type of the failure, and allows (optionally)°dONLNdk
âO
ï
Ã*Stransmission of data that may explain the reason for the failure.  The NewtonScript°dONLNdø
ïO
°
ı*_implemention uses the exception system to report errors (for example, errors in an application,°dONLNd
°O
≠
˜*cfailures due to lack of resources, or internal errors).  Developers can use the exception system to°dONLNdÉ
≠O
π
q*?communicate errors between different modules in an application.
°dONLNd√
ƒ*
׉(
ÒHBasic Syntax

°dONLNd–
◊N
„ˆ+$%The Exception handling is based on a ,
Courier°dONLNdı
◊ˆ
„
,)®    try block°dONLNd˛
◊
,
„
 )6$, and if an exception is thrown from°dONLNd#
„O
Ô
D(m5somewhere, the code should catch this with a special °dONLNdX
„
D
Ô
Ü)ıonException°dONLNdc
„
Ü
Ô
£)B block.
°dONLNdk*ú(8HTry Statements

°dONLNdzN*
+$+The general format of the try statement is:°dONLNd¶5NA`*try°dONLNd´@rL“+$<statement list>°dONLNdºKNW
(sl!onexception <exception symbol> do°dONLNdflVrb¥+$<statement>°dONLNdÎaNm
(âl!onexception <exception symbol> do°dONLNdlrx¥+$<statement>°dONLNdwNÉ`(ül...°dONLNdéNö—*An example of this might be:
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
4ˇ∞◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd5NA`*2try°dONLNd@NLl*begin°dONLNdKrW
h+$)// create entries and store them to soups°dONLNd5VNb`(~lend°dONLNd9aNm
*!onexception |ext.ex.store.err| do°dONLNd[lNxl*begin°dONLNdbwrÉ
»+$9// problems with the store, most likely not enough memory°dONLNdùÇréÃ*// do something°dONLNd≠çNô`(µlend°dONLNd±§N∞
‹*WThe <exception symbol>s  must be single part exception symbols. Details about exception°dONLNd
    ∞Oº
â+
Dsymbols — that is,  what multiple parts mean —  are discussed below.°dONLNd
N»N‘
˙(l_One or more onexception clauses are allowed. The try statement executes <statement list>. If no°dONLNd
Æ‘O‡
˛+
bexceptions are thrown in the process, then the value of the try statement is the value of the last°dONLNd‡OÏ
¨*Mstatement in <statement list> and the onexception clauses are never executed.°dONLNd_¯N

˚(
 l`If during execution of <statement list> an exception is thrown, then the execution of <statement°dONLNd¿
O

¯+
blist> stops and control is transferred to one of the onexception clauses. When an exception, X, is°dONLNd#
O

Â*\raised, the onexception clauses of the try statement are examined in order. The first clause°dONLNdÄ
O
(
˘*^whose <exception symbol> is a prefix of any of X's parts is executed and its <statement> value°dONLNdfl
(O
4
*'becomes the value of the try statement.°dONLNd
AN
M
‘(
ilXIf no onexception clause matches the exception, then the exception is passed to the next°dONLNd`
MO
Y
ˆ+
^enclosing try statement for processing. In a Newton application, the exception will ultimately°dONLNdø
YO
e
˛*`be handled by the view system (putting up an error dialog box) if your application doesn't catch°dONLNd 
eO
qZ*it.°dONLNd$
}N
â
˘(
•l^NOTE:  It is important that the search for a matching onexception clause uses dynamic scoping,°dONLNdÉ
âO
ï•+
not lexical scoping.°dONLNdò
°N
≠
Ê(
…l\Since all exceptions have an evt.ex part, an exception clause with evt.ex as its symbol will°dONLNdı
≠O
π
‘+
Zcatch any exception. (See the following section for a description of "parts".) If your try°dONLNdP
πO
≈
˚*dstatement has an evt.ex clause,  it should be last, since onexception clauses occuring after it will°dONLNdµ
≈O
—
Ï*^never be executed. In general, you should order your onexception clauses from most specific to°dONLNd
—O
ݎ*least specific.
°dONLNd$
È*
¸∏(HException Symbols

°dONLNd6
¸N
È+$VExceptions have names which are symbols.  These symbols have a particular format which°dONLNdçO
Ú+
^must be adhered to.  An exception name consists of one or more parts separated by semi-colons.°dONLNdÌO 
>*5Each part is a structured name beginning with evt.ex.°dONLNd$,N8Ù(Tl%A  few facts about exception symbols:°dONLNdK8rD
6+$*• They can have as many as 127 characters.°dONLNdwDrP
ÿ*R• They can contain periods, so the symbols must be enclosed in vertical bars (|'s)°dONLNdÀPr\
z*9• They can have multiple parts, separated by semi-colons.°dONLNd    \rh
A*-• They must have a part starting with evt.ex.°dONLNd    4tNÄ
Ï(úlZThe simplest possible exception symbol is |evt.ex|. An example of an exception symbol with°dONLNd    èÄOå
§+
Ktwo parts would be '|evt.ex;type.ref|.  Some more examples: '|evt.ex.div0|,°dONLNd    €åOòÊ*"'|evt.ex.fr.intrp;type.ref.frame|.,    Helvetica
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
5ˇ˛◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language
°dONLNd5*H∞(bHException Frames

°dONLNdHNT
˝+$]Associated with every exception is an exception frame. When handling an exception you can get°dONLNdoTO`
Â+
Ythis frame using the global function, CurrentException(). An exception frame always has a°dONLNd…`Ol
Û*\name slot which contains the exception symbol. It will contain one other slot whose name and°dONLNd
&lOx
Ú*]contents depend on the type of exception as follows: (this info is summarized on the NS Quick°dONLNd
ÑxOÑ|*    Ref Card)°dONLNd
éêNú
˙(∏lc• if  type.ref is a prefix in the exception symbol, then the other slot will be called data and can°dONLNd
ÚúO®ü+
contain anything.,
Courier°dONLNd∂N¬
z(fil2|evt.ex;type.ref|: {name: <string>, data: <frame>}°dONLNd7ÃNÿ
˛*HEx: {name: "the llama exception", data : {type: 'inka, size: 42, weight:°dONLNdÄ◊N„l*177}}°dONLNdÜÓN˙
Ó*_• if evt.ex.msg is a prefix in the exception symbol, then the other slot will be called message°dONLNdÊ˙O
ß+
and contain a string°dONLNd˚
N
 
t(
<l1|evt.ex.msg|: {name: <string>, message: <string>}°dONLNd-
*N
6
‡*CEx: {name: "Ho ho exception", message: "You have a serious problem,°dONLNdq
5N
Ar*mate"}°dONLNdx
NN
Z
—*Y• otherwise, the other slot will be called error and will contain an integer (error code)°dONLNd“
hN
t
V*,|evt.ex|: {name: <string>, error: <integer>}°dONLNdˇ
~N
ä
\*-Ex: {:name: "Hi Ho exception", error: -48666}°dONLNd-
óN
£
>*5Here are examples of exception frames from real life:°dONLNdc
£N
Ø⁄*• Example A,  division by zero:°dONLNdÉ
ØN
ª
,*%{name: |evt.ex.div0|, error: 1764744}°dONLNd©
ΔN
“
[*?If you want to catch division by zero errors, here's the trick:°dONLNdÈ
“N
fi`*try°dONLNdÓ
›r
ÈÑ+$5/0°dONLNdÚ
ËN
Ùÿ(lonexception |evt.ex| do°dONLNd
Ûr
ˇ‰+$CurrentException();°dONLNd
NÊ(2l • Example B, undefined variable:°dONLNd@N"
¯*G{name: |evt.ex.fr.interp; type.ref.frame|, data: {error:-48807, symbol:°dONLNdà!N-l*foo}}
°dONLNdéD*W
(qHHow to Raise Gentle Exceptions

°dONLNd≠cNo
Ò+$ZYou can throw an exception using the global function, Throw(<exception symbol>, <exception°dONLNdoO{
+
]data>). The value you pass for <exception data> is put into the "other" slot of the exception°dONLNdf{Oá
˜*bframe. Make sure it is the correct type (as per the above rules) or your  call to Throw will raise°dONLNd…áOì£*another exception.,    Helvetica
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
6ˇ‘◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd)N5
Ó*&`If the code block has more than one try statement in effect at one time, you can pass control to°dONLNda5OA
^+
=the next enclosing try statement using the Rethrow  function.°dONLNd†NNZ
(vl[Here are examples of the three different ways to create and throw exceptions. Note that you°dONLNd¸ZOfÒ+
%need to send an exception symbol ('):,
Courier°dONLNd
"qN}‰(ôlThrow('|evt.ex.foo|, 99);°dONLNd
<áNì
*Throw('|evt.ex.msg|, "string");°dONLNd
\ùN©
Ü*4Throw('|evt.ex;type.ref.something|, ["a", "b", "c"])
°dONLNd
ëø*“˛(ÏHDefault Exception Handling

°dONLNd
¨“Nfi
fl+$ZUnfortunately, there is currently no general way for your application to specify a default°dONLNdfiOÍ
Ã+
Sexception handler, for example, viewExceptionScript. This means you need to use try°dONLNd[ÍOˆ
3*1statements wherever you want to catch exceptions.
°dONLNdç

*
s(
.HExamples

°dONLNdñ
N
 
µ+$SHere's some code  to test out the exception system. This tries various cases and is°dONLNdÍ
 N
,
µ*Pdesigned to print no output, assuming  the exception system works as advertised.°dONLNd;
,N
8
ê*FHowever,  the NTK Inspector prints out every exception that is thrown,°dONLNdÇ
8N
D
y*Cwhether it's handled or not. Expect to see output; however, none of°dONLNdΔ
DN
P
!*.thePrint("*error?*) statements should execute.°dONLNdı
\X
h
+
//simple cases & a nested block°dONLNd
gX
sj*try°dONLNd
ri
~á+begin°dONLNd$
à|
îé+try°dONLNd+
ìç
ü
}+(Throw('|evt.ex;type.ref;foo|,"dsafsda");°dONLNdW
ûç
™˘*Print("*error*1");°dONLNdl
©|
µÙ(
—öonexception |foo| do°dONLNdÑ
¥ç
¿´+begin°dONLNdé
øû
À
@+//Exception handled quietly°dONLNd¨
 |
ւ(
Úö
 °dONLNdÆ
 ç
÷•)end;°dONLNdµ
’|
·Ç(
˝ö
 °dONLNd∫
‡|
Ïé*try°dONLNd¡
Îç
˜
}+(Throw('|evt.ex;type.ref;foo|,"dsafsda");°dONLNdÌ
ˆç˘*Print("*error*2");°dONLNd
|

()öonexception |type.ref| do°dONLNdç´+begin°dONLNd)û#
@+//Exception handled quietly°dONLNdG"|.Ç(Jö
 °dONLNdI"ç.•)end;°dONLNdQ8iD
G(`á%  //outer block should catch this one°dONLNdyC|O
+Throw('|evt.ex.foobar|,42);°dONLNdòNçZì+
 °dONLNdúYie·(Åá  Print("*error*3");°dONLNd≤oi{{*end°dONLNd∂zXÜ‚(¢vonexception |evt.ex| do°dONLNdœÖië
M+&if CurrentException().error <> 42 then°dONLNd¯ê|úö+begin,    Helvetica
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
7ˇ    V◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd)ç5˘+?&Print("*error*4");°dONLNd4ç@
#*Print(CurrentException())°dONLNd2?|Kî(göend;°dONLNd7kXw (ìv//try out rethrow()°dONLNdKvXÇj*try°dONLNdPÅiçá+begin°dONLNd[ó|£é+try°dONLNdb¢çÆ
+Throw('|evt.ex|,42);°dONLNdz≠çπ˘*Print("*error*5");°dONLNdè∏|ƒ
(‡öonexception |evt.ex| do°dONLNd™√眴+begin°dONLNd±Œi⁄
Y(ˆá(     //outer block should catch this one°dONLNdfiŸûÂ⁄+5
Rethrow();°dONLNdΉ|Ç(
ö
 °dONLNd̉ç•)end;°dONLNdı˙i
’(
"áPrint("*error*6");°dONLNd


|
Ç+
 °dONLNd

i
{(
8áend°dONLNd

X
'‚(
Cvonexception |evt.ex| do°dONLNd
+
&i
2
M+&if CurrentException().error <> 42 then°dONLNd
T
1|
=ö+begin°dONLNd
]
<ç
H˘+Print("*error*7");°dONLNd
s
Gç
S
#*Print(CurrentException())°dONLNd
è
R|
^î(
zöend;°dONLNd
î
sX
Ù(
õv//try it out with fn calls°dONLNd
Ø
~X
äj*try°dONLNd
¥
âi
ïá+begin°dONLNd
ø
ü|
´æ+call func()°dONLNd
Œ
™ç
∂´+begin°dONLNd
ÿ
µû
¡∞+try°dONLNd
·
¿∞
Ã
–+0call func(esym) Throw(esym,42) with ('|evt.ex|);°dONLNd
˰
◊
*Print("*error*8");°dONLNd.
÷û
‚
4(
˛ºonexception |type.ref| do°dONLNdM
·∞
ÌŒ+begin°dONLNdV
Ïç
¯
}(´(     //outer block should catch this one°dONLNdÖ
˜¬˛+5
Rethrow();°dONLNdîû§(*º
 °dONLNdñ∞»)end;°dONLNdû
çü(5´end°dONLNd§|$¨(@öwith ();°dONLNd≤.|:Ë*Print("*error*9");°dONLNd«9|EÇ*
 °dONLNdÀDiP{(láend°dONLNdœOX[‚(wvonexception |evt.ex| do°dONLNdËZif
M+&if CurrentException().error <> 42 then°dONLNde|qö+begin°dONLNdpç|ˇ+Print("*error*10");°dONLNd1{çá
#*Print(CurrentException())°dONLNdMÜ|íî(Æöend;,    Helvetica
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
8ˇT◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd4X@
+
1Print("no news, is good news");,    Monaco
    °dONLNd X*c
¯(ÄHM_____________________________________________________________________________
°dONLNdoçN™
G+$BNewtonScript Q&As,    Helvetica
°dONLNdÇΔNÿ
¸*1+___________________________________________
°dONLNdÆÿNË
‡*>Garbage Collection (10/15/93) (Obsoleted by NS Guide 1.0 Final°dONLNdÌËN¯µ*Documentation)

°dONLNd¸
N

˝*_In NewtonScript, the run-time module, not the programmer, is responsible for allocating storage°dONLNd
\
O

˙+
dfor objects and for reclaiming the storage of objects that are no longer used. Garbage collection is°dONLNd
¡
O
(
Ï*_carried out by the basic object system, so it’s not technically NewtonScript that does it.  The°dONLNd!
(O
4
Û*astorage taken up by an object will be freed sometime after the last reference to that object goes°dONLNdÉ
4O
@l*away.°dONLNdâ
LN
X
fi(
tlXOne of the many benefits of garbage collection is that the programmer has to think about°dONLNd‚
XO
d
‚+
[freeing objects only  in a small number of important places, as opposed to dealing with the°dONLNd>
dO
p
Í*Zconstant background worry that objects must be freed. Wth automatic garbage collection you°dONLNdô
pO
|
4*6only need to consider disposing objects in rare cases.°dONLNd–
àN
îÆ(
∞lOne place where you °dONLNd‰
àÆ
îœ)`should °dONLNdÎ
àœ
î
Ú)!Athink about it is when you close an application; here you want to°dONLNd-
îO
†
„(
ºm_free as much storage as possible. You do this by either removing slots  or by setting slots to °dONLNdå
î
„
†
ı(
º
nil°dONLNdê
†O
¨
Ó(
»m`in the application's context frame.  Setting the value of all slots and variables referring to a°dONLNdÒ
¨O
∏¶*particular object to °dONLNd
¨¶
∏∏)Wnil°dONLNd    
¨∏
∏
û)4 allows the Garbage Collector to destroy the object.°dONLNd>
ƒN
–
˙(
Ïl\Within the Newton operating system, automatic garbage collection is triggered every time the°dONLNdõ
–O
‹
¸+
_system runs out of memory. There's not really any reason to invoke garbage collection manually.°dONLNd˚
‹O
Ë
ú*JHowever, if you must do so, you can call the global NewtonScript function °dONLNdE
‹
ú
Ë
®(
∫GC°dONLNdG
‹
®
Ë
·)
. Consult the°dONLNdU
ËO
Ù–(mNewton Programmer’s Guide°dONLNdn
Ë–
Ù
G)Å to find out more about the °dONLNdä
Ë
G
Ù
Y)wGC °dONLNdç
Ë
Y
Ù
Ä)    function.
°dONLNdòN
¸(-l+___________________________________________
°dONLNdƒN"
%*"Order of Slots in Frames (9/15/93)

°dONLNdË2N>[*Q: °dONLNdÏ2`>
◊)SThe description of the foreach function in the manual might be taken as a hint that°dONLNd@>`J
ÿ*Uslots in frames are ordered.  Does slot or array order imply anything about layout of°dONLNdñJ`V

*#data in memory (as with C structs?)°dONLNd∫bNn[(älA: °dONLNdæb`n
⁄)USlots are not ordered, nor have we seen any performance gains from ordering slots for°dONLNdn`z
—*Uparticular sequences or search criteria. Don’t count on their being in any particular°dONLNdjz`Ü
µ*Lorder, nor on data structures in memory being ordered with any regard to the°dONLNd∑Ü`í
¶*Fplacement of slots (as in the ANSI Common LISP object extension CLOS).
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)¯
9ˇ
∂◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd5NAY*2Q:°dONLNd5`A
u)<Where is a newly-defined slot placed in a frame? at the end?°dONLNd@MNYY(ulA:°dONLNdCM`Y
ƒ)PBecause slots are unordered, the location of a new slot cannot be predetermined.,    Helvetica
°dONLNdïuNá
¸(¢l+___________________________________________
°dONLNd¡áNó
*Structured Literals (9/15/93)

°dONLNd‡ßN≥[*Q: °dONLNd‰ß`≥
≈)TIs it really dangerous to assign a string literal to a variable, as in the following°dONLNd
9≥`øå*example?,
Courier°dONLNd
CÕrŸ¥+s := "abc";°dONLNd
OÊNÚ[(
lA: °dONLNd
SÊ`Ú
_)9That depends on what you're going to do with s. If you're°dONLNd
éÚ`˛
m*?going to modify it, then yes, it's dangerous. In that case, you°dONLNd
œ˛`

è*
should use°dONLNd
‹
r
$fi+s := Clone("abc");°dONLNd

1`
=
g(
Y~;In general you should treat string literals in NewtonScript°dONLNd-
=`
I
Ü*Bas read-only (just as you should in ANSI C). String literals might°dONLNdq
I`
U
Ç*@reside in read-only memory or share storage with other literals.°dONLNd≥
a`
m
Õ*PThe same warning applies to quoted array and frame literals, as in the following°dONLNd
m`
yä*example:°dONLNd
ár
ì
b+( '[1,2,3] or '{one: 1, two: 2, three: 3}°dONLNd8
†`
¨
æ(
»~NHere are some rules regarding string literals and quoted array/frame literals:°dONLNdà
∏`
ƒ
P*5- Treat them as read only. Use clones when necessary.°dONLNd¡
–`
‹
º*M- Realize that they always represent the same object.   In the example below,°dONLNd
Ír
ˆˆ+func foo() begin "abc"°dONLNd(
ır
ä*end;°dONLNd,NP(6l
 °dONLNd0`
X)9- always returns exactly the same string - not different,°dONLNdk`&¥*equivalent strings.°dONLNdÄ2`>
Å*B- In your code, an unquoted array or frame literal will generate a°dONLNdƒ>`J
ï*Fnew array or frame each time it is evaluated. So it’s acceptable for a°dONLNdJ`V
h*Afunction to return [1,2,3] or {one: 1,two: 2,three: 3} as long as°dONLNdOV`bµ*they're not quoted.
°dONLNdd|Né
¸(©l+___________________________________________
°dONLNdêéNû

*Passing Arguments (9/15/93)
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û10ˇ
¶◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd9NE[*6Q: °dONLNd9`E
K)3Is NewtonScript call-by-reference or call-by-value?°dONLNd8QN][(ylA: °dONLNd<Q`]
œ)QA seemingly simple question. The short answer is “call-by-value,” the litmus test°dONLNdé]`iè*
being that,
Courier°dONLNdöwrÉÍ+ func foo(x) x := 1;°dONLNd∞ê`ú
‘(∏~Sdoes not affect the argument passed to it. However, this is not meant to imply that°dONLNd
ú`®
◊*QNewtonScript functions can never make changes to their arguments. If the argument°dONLNd
V®`¥
Õ*Qhas structure—for example, if it’s an array, frame, or string—then changes to the°dONLNd
®¥`¿
£*Iinternal structure are persistent. Consider the following code fragments:°dONLNd
ÚÕNŸT(ıl
 °dONLNd
ÙÕrŸˆ)$func foo(x) x[0] := 1;°dONLNd
ÿr‰
Ä*-// changes the 1st element of array arguments°dONLNd>Ór˙
*func foo(x) x.slot1 := 1;°dONLNdZ˘r

z*,// changes the slot1 slot of frame arguments°dONLNdà
`

√(
:~MDepending on what you’re used to, this example might be confusing because the°dONLNd÷
`
*
œ*Qconcepts of call-by-reference, call-by-value are mixed, and copying arguments are°dONLNd(
*`
6
⁄*Sintertwined (and often misunderstood.) The following discussion of this terminology°dONLNd|
6`
B
á*Awith respect to other languages may help clarify the differences.°dONLNdø
N`
Z
Œ*OPascal - Supports both call-by-reference (VAR parameters) or call-by-value (the°dONLNd
Z`
f
´*Idefault). When array or record arguments use call-by-value, copies of the°dONLNdY
f`
r
÷*Narrays/records are made and passed in. To Pascal programmers, NewtonScript may°dONLNd®
r`
~
I*1seem to pass arrays and frames as VAR parameters.°dONLNd€
ä`
ñ
à*CC - Only supports call-by-value. Struct (not struct*) arguments are°dONLNd 
ñ`
¢
“*Spassed as values; that is, a copy of the struct is passed. However, array arguments°dONLNdt
¢`
Æ
◊*Tpass in the address of the first element of the array. Thus, C programmers will find°dONLNd…
Æ`
∫
&*+the array arguments to be treated normally.°dONLNdˆ
Δ`
“
ò*ELISP - Only supports call-by-value. Copies are not made of structured°dONLNd=
“`
fi
Œ*Targuments (lists, structures, arrays, objects,...) Argument passing in Newton Script°dONLNdí
fi`
ÍÁ* works just like it does in LISP.,    Helvetica
°dONLNd¥
¸N
fi()l(________________________________________
°dONLNd›N
* Slot (Variable) Lookup (9/15/93)

°dONLNdˇ.N:[*Q: °dONLNd.`:
ì)CWhat differences are there among the various ways to access a slot?°dONLNdGFNRY(nlA:°dONLNdJF`R
Δ)NThe means by which you access a slot specifies the search path and inheritance°dONLNdôR`^
‚*Xmechanisms used to locate it. Each of the five ways to access a slot is described below.°dONLNdÛj`vÏ*•Specifying the slot name only°dONLNdÇ`é
d*;If you specify only the name of the slot, as in the example
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û11ˇZ◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd)r5ú+$&theSlot°dONLNd    @`L
…(h~Qthe search begins in the current function frame with lexically-visible variables,°dONLNd[L`X
fl*Wfollowed by slot names. In other words, if the currently-executing function has a local°dONLNd≥X`d
 *Pvariable named theSlot, it is found before a local variable named theSlot in the°dONLNd
d`p
Œ*Tenclosing function, and so on. Similarly, any of those variables are found (in scope°dONLNd
Yp`|
·*Worder) before an actual slot named theSlot is found. If a variable named theSlot is not°dONLNd
±|`à
„*Yfound, global variables are searched next. If a global variable is not found, the current°dONLNdà`î
,*.receiver is searched for a slot named theSlot.°dONLNd;†`¨
¡*QIf the slot is not found in the receiver of the message, the remaining frames are°dONLNdç¨`∏
⁄*Tsearched in order of prototype and parent inheritance. An exception is thrown if you°dONLNd‚∏`ƒ
 *Utry to access a slot that can't be found.  If you do an assignment operation using an°dONLNd8ƒ`–
À*Wundeclared slot, the slot is created if you place the self. prefix in front of the slot°dONLNdê–`‹
◊*Uname; if you do the operation without the self. prefix you will get a local variable.°dONLNdÁÙ`
Ÿ*$•Using the dot (.) operator°dONLNd
`

¬*QIf you use the dot operator to specify the frame and the slot,  as in the example°dONLNdW
$r
0Δ+myframe.myslot°dONLNdg
;`
G
Δ(
c~Tthe search begins in the specified frame.  If the slot is not found in the specified°dONLNdº
G`
S
ÿ*Sframe, the remaining frames are searched in order of prototype inheritance.  Parent°dONLNd
S`
_
›*Winheritance paths are not searched. If the slot does not exist, the system returns NIL.°dONLNdk
w`
É›*$•Using the GetSlot function°dONLNdà
è`
õé*If you call°dONLNdñ
©r
µÍ+GetSlot(frame, slot)°dONLNd≠
¬`
Œ
‹(
Í~Vonly the specified frame is searched for the specified slot. Inheritance paths are not°dONLNd
Œ`
⁄å*    searched.°dONLNd
Ê`
ÚÙ*•Using the GetVariable function°dONLNd0
˛`
é*If you call°dONLNd>r$
+GetVariable(frame, slot)°dONLNdY/`;
€(W~Ythe search begins in the specified frame.  If the slot is not found in the current frame,°dONLNd≥;`G
…*Othe remaining frames are searched in order of prototype and parent inheritance.°dONLNd_`k
'*$)•GetVar will be removed from the language°dONLNd.wNÉ
˝(ül_You can usually simulate GetVar using GetVariable(self,slot). The difference will be that local°dONLNdéÉOè˛+
)variables will not be found - only slots.,    Helvetica
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û12ˇ∂◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd)N5
˘*&`If you use GetVar you may find that is not available in future products, in which case your code°dONLNda5OA
˘+
]will throw an exception; or  GetVar may work differently not finding local variables anymore,°dONLNdøAOM
´*Kin which case your code may subtly break. DTS advises against using GetVar.,    Helvetica
°dONLNd
[Nm
¸(àl+___________________________________________
°dONLNd
8mN}
¯*ETesting the Existence of a Slot (Variable) (9/15/93) (Obsoleted by NS°dONLNd
~}NçÚ*1.0 Final Documentation).

°dONLNd
òõNß[*Q: °dONLNd
úõ`ß
À)MWhat differences are there among the various ways to determine whether a slot°dONLNd
Íß`≥Ø*exists in a frame?°dONLNd
˝øNÀY(ÁlA:°dONLNdø`À
·)VThe means by which you test for a slot's existence specifies the search path and kinds°dONLNdWÀ`◊
Ã*Qof inheritance used to discover it. The following examples describe three ways to°dONLNd©◊`„
*,discover the existence of a slot in a frame.°dONLNd◊Ô`˚Ÿ*• Using the exists operator°dONLNdÙ
`

÷*TThe exists operator follows the same rules as the expression to which it is applied.°dONLNdI
`

·*YFor example, if you use this operator to test a slot access expression, as in the example,
Courier°dONLNd§
-r
9+myframe.myslot exists°dONLNdº
F`
R
€(
n~Ythe search begins in the specified frame.  If the slot is not found in the current frame,°dONLNd
R`
^
Ã*Pthe remaining frames are searched in order of prototype inheritance only. Parent°dONLNdg
^`
j

*#inheritance paths are not searched.°dONLNdå
v`
Ç
€*THowever, when using the exists operator to check whether an identifier exists, as in°dONLNd·
Ç`
éô*the example°dONLNdÓ
úr
®∫+myvar exists°dONLNd˝
µ`
¡
j(
›~9both prototype and parent inheritance paths are searched.°dONLNd8
Õ`
Ÿ‚*• Using the HasSlot function°dONLNdV
Â`
Òé*If you call°dONLNdc
ˇrÍ+HasSlot(frame, slot)°dONLNdy`$
‹(@~Vonly the specified frame is searched for the specified slot. Inheritance paths are not°dONLNd–$`0å*    searched.°dONLNd€<`H˘* • Using the HasVariable function°dONLNd˝T``é*If you call°dONLNd
nrz
+HasVariable(frame, slot)°dONLNd$á`ì
‡(Ø~Zthe search begins in the current frame. If the slot is not found in the current frame, the°dONLNdì`ü
∑*Kremaining frames are searched in order of prototype and parent inheritance.
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û13ˇ⁄◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,    Helvetica
°dONLNdˇˇ*7+___________________________________________
°dONLNdGNW
È*>Calling Methods Out Of Slot Context (9/15/93) (Obsoleted by NS°dONLNd?WNg
*Guide 1.0 Final Documentation)

°dONLNd^wNÉ[*Q: °dONLNdbw`É
Δ)SI'm trying to pull a method out of a slot and call it. Unfortunately, the functions°dONLNd∂É`è
}*Aapply and call both seem to set self to {}. Is there another way?°dONLNd¯õNß[(√lA: °dONLNd¸õ`ß
€)OThe global function Perform(frame, message, paramaterArray) does what you want,°dONLNd
Lß`≥
›*Wexcept that the method needs to be in a slot in the current frame if you really want to°dONLNd
§≥`ø÷*preserve the value of self.
°dONLNd
¡ N‹
¸(˜l+___________________________________________
°dONLNd
Ì‹NÏ
û*5Inherited (10/13/93) (Obsoleted by NS Guide 1.0 Final°dONLNd#ÏN¸µ*Documentation)

°dONLNd2
N
[*Q: °dONLNd6
`

W)6What is the function of "inherited:" and "inherited:?"°dONLNdm
$N
0
‘(
LlUA:  In NewtonScript, the inherited:X() message send specifies a NewtonScript function°dONLNd√
0`
<
”+Scall on the function X, where X is found UP the inheritance chain starting from the°dONLNd
<`
H
÷*Scaller's _proto. In other words, lookup for that method ONLY starts up the caller's°dONLNdk
H`
T
‚*U_proto chain, NOT in  "self" (the currently executing frame). The conditional message°dONLNd¡
T`
`z*send (,
Courier°dONLNd«
Tz
`Ü):?°dONLNd…
TÜ
`®)), with °dONLNd—
T®
`‰)"
inherited °dONLNd€
T‰
`
‚)<8specified, operates almost exactly the same  except that°dONLNd
``
l
fi(
à~Uno error results if the given method (function) is NOT found. The conditional message°dONLNdj
l`
xz*send (°dONLNdp
lz
xÜ):?°dONLNdr
lÜ
x®)), with °dONLNdz
l®
x‰)"
inherited °dONLNdÑ
l‰
x
‡)<8specified, is helpful in complex heirarchies because you°dONLNdΩ
x`
Ñ
ÿ(
†~Ocan use it without  worrying about whether any such method was ever implemented°dONLNd

Ñ`
ê
*#higher up in the inheritance chain.
°dONLNd2
®N
∫
¸(
’l+___________________________________________
°dONLNd^
∫N
 
Ì*BDeeply (foreach deeply in...) (10/13/93)(Obsoleted by NS Guide 1.0°dONLNd°
 N
⁄Ÿ*Final Documentation)

°dONLNd∏
N
¸[*#Q: °dONLNdº
`
¸
í)AWhat is the difference between "foreach" and "foreach deeply in"?°dONLNd˛N
›(0lZA:  'Deeply' specifies that only the slots/elements of the current frame/array are listed,°dONLNdY` 
“+Texcept that if passed a frame, slots of ancestors up the _proto chain are considered°dONLNdÆ `,Ê*elements of the current frame.°dONLNdœ8`D
§*IHere is some Inspector code to illustrate the difference between the two:°dONLNdPr\“+//oo DEFINITIONS°dONLNd,[rg
*normallist := func (param)°dONLNdHfNr`(él   °dONLNdLfrrê)$begin°dONLNdRqN}r(ôl      °dONLNdYqñ})Hlocal tempItem;°dONLNdi|Nàr(§l      °dONLNdp|ñà
,)Hforeach tempItem in param°dONLNdãáNì
 (Øl#                  collect tempItem;°dONLNdØíNû`*   °dONLNd≥írûä)$end;
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û14ˇ    æ◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd)r5
+$&deeplylist := func (param)°dONLNd4N@`(\l   °dONLNd 4r@ê)$begin°dONLNd&?NKr(gl      °dONLNd-?ñK)Hlocal tempItem;°dONLNd=JNVr(rl      °dONLNdDJñV
V)H foreach tempItem deeply in param°dONLNdfUNa
 (}l#                  collect tempItem;°dONLNdä`Nl`*   °dONLNdé`rlä)$end;°dONLNdîårò“*,//oo SAMPLE DATA°dONLNd¶ór£
2* x := {one: 1, two: 2, three: 3};°dONLNd»≠rπ
8*!y:= {four: 4, five: 5, combo: x};°dONLNdÎ√rœ
*z:= {six: 6, _proto: y};°dONLNd
ŸrÂ
∂*6complex := {a: "first string", b: ["array1", "array2",°dONLNd
?‰ñ
>+${_proto: x}], c: 3.1415926};°dONLNd
g
r
'Æ(
Cê
//oo TESTS°dONLNd
s
&r
2
,*:normallist(x)          // same°dONLNd
î
1r
=‰*#4413441  [1, 2, 3]°dONLNd
©
<r
HΔ*:deeplylist(x)°dONLNd
π
Gr
S‰*#44137D9  [1, 2, 3]°dONLNd
Œ
hr
t
,*!:normallist(y)          // same°dONLNd
Ô
sr
¿*
#4413A11  [4,°dONLNd
˛
~N
äú(
¶l
           5,°dONLNd

âN
ï¿*           {One: 1,°dONLNd"
îN
†¿*            two: 2,°dONLNd7
üN
´“*            three: 3}]°dONLNdO
™r
∂Δ+$:deeplylist(y)°dONLNd_
µr
¡¿*
#4413C49  [4,°dONLNdn
¿N
Ãú(
Ël
           5,°dONLNd}
ÀN
◊¿*           {One: 1,°dONLNdí
÷N
‚¿*            two: 2,°dONLNdß
·N
Ì“*            three: 3}]°dONLNdæN
™*!:                        // For z, the answer is different.°dONLNd˙
N
‡*C                        // the deeply version travels proto chains!°dONLNd?r$Δ+$:normallist(z)°dONLNdO#r/¿*
#4416E29  [6,°dONLNd^.N:Δ(Vl           {four: 4,°dONLNdt9NEΔ*            five: 5,°dONLNdäDNP
*            combo: {#4415D79}}]°dONLNd≠erqΔ+$!:deeplylist(z)°dONLNdΩpr|¿*
#4416FE1  [6,°dONLNdÃ{Náú(£l
           4,°dONLNd€ÜNíú*
           5,°dONLNdÍëNù¿*           {One: 1,,    Helvetica
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û15ˇê◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd)N5¿*&            two: 2,°dONLNd4N@“*            three: 3}]°dONLNd,UNa
Ê*!D                 // for this complex frame, the answers are the same°dONLNdr`Nl
¯*G                 // because there is no _proto slot in the *MAIN* frame°dONLNdªkNw
º*=                 // hence there is nowhere to go deeply into.°dONLNd˙vrÇÍ+$:normallist(complex)°dONLNd
Årç
*#4418741  ["first string",°dONLNd
,åNò
V(¥l,           ["array1", "array2", {#44183B9}],°dONLNd
ZóN£¿*           3.14159]°dONLNd
o≠rπÍ+$:deeplylist(complex)°dONLNd
Ö∏rƒ
*#4418AC1  ["first string",°dONLNd
°√Nœ
V(Îl,           ["array1", "array2", {#44183B9}],°dONLNd
œŒN⁄¿*           3.14159],    Helvetica
°dONLNd
‰ÚN

¸*)+___________________________________________
°dONLNd
N

Œ*;Compile Function (10/9/93) (Obsoleted by NS Guide 1.0 Final°dONLNdL
N
$µ*Documentation)

°dONLNd[
7N
C[* Q: °dONLNd_
7`
C
€)TI need the ability to download the validtest and endtest functions to the Newton for°dONLNd¥
C`
O
œ*Tsearches.  I do not see how I can convert the incoming textual representation of the°dONLNd    
O`
[
7*2function to code to execute.  How could I do this?°dONLNd<
gN
sY(
èlA:°dONLNd?
g`
s
„)TYou could use the special compile function in NewtonScript. Here's an example of how°dONLNdî
s`
¢*to use compile:°dONLNd•
ãÑ
ó¢+$begin°dONLNd´
ñr
¢x(
æê
 °dONLNdÆ
ññ
¢Ã)$     local x;°dONLNd∏
¨r
∏x(
‘ê
 °dONLNdª
¨ñ
∏
Ï)$9 // Set x to be a function that returns the new function.°dONLNdı
∑r
√x(
flê
 °dONLNd¯
∑ñ
√
b)$" x := Compile("Print(\"Hello\")");°dONLNd
Õr
Ÿ~(
ıê  °dONLNd
ÕÑ
Ÿê)  °dONLNd!
Õñ
Ÿ
å))// Now call the actual compiled function.°dONLNdK
ÿr
‰~(ê  °dONLNdO
ÿñ
‰)$call x with ();°dONLNd_
Ór
˙~(ê  °dONLNdc
Óñ
˙
‡)$7// At this point, "Hello" will have been printed to the°dONLNdõ
˘r∫(!êinspector...°dONLNd©Ñú+end;°dONLNdØ`'
Œ(C~QNote that compile returns a function taking no arguments whose body is the string°dONLNd
'`3
€*Wpassed to compile.  If you need to create a function taking arguments, you can create a°dONLNdY3`?
–*Qfunction with Compile whose return value is a function that takes arguments, like°dONLNd´?`Kv*this:°dONLNd±Wrc
h+)f := call Compile("func(x) x*x") with ();°dONLNd€brn
8*!call f with (10);  // prints 100.
°dONLNd˛xNä
¸(•l+___________________________________________
°dONLNd*äNö
*Function Definitions (10/9/93)
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û16ˇ‘◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd9NEY*6Q:°dONLNd9`E
€)]Is it "safer" to use a return statement at the end of a function or is it just a style issue?°dONLNdaQN]Y(ylA:°dONLNddQ`]
◊)TAll functions return the last value in the function body. This means that you have a°dONLNdπ]`i
»*Qchoice of explicitly writing a return statement, or assuming that the code reader°dONLNd
i`u
a*8knows that the last statement is automatically returned.°dONLNd
EÅ`ç
ÿ*POne might argue that a return statement should always be used. However there are°dONLNd
ñç`ô
„*Vcases where the code looks prettier with no return statement, and the return statement°dONLNd
Ìô`•
d*7does generate code. Compare the following two examples:,
Courier°dONLNd&±ÑΩ¢+$begin°dONLNd.ºñ»®+...°dONLNd4«ñ”
,*if expr then "" else text°dONLNdO“Ñfiñ(˙¢end°dONLNdTÛÑˇ¢*!begin°dONLNd\˛ñ

fi+if expr then°dONLNdl
    ®
fi+    return ""°dONLNdx
ñ
 Æ(
<¥else°dONLNdÄ
®
+Í+return text°dONLNdç
*Ñ
6ñ(
R¢end°dONLNdí
A`
M
ÿ(
i~TAdditionally, in the current NewtonScript compiler, an extra byte or two is used for°dONLNdÁ
M`
Y
◊*Uthe return statement, but in most cases it will make no apparent difference in speed.,    Helvetica
°dONLNd>
Yr
k
¯+'_______________________________________°dONLNde
kO
}w(
òm____
°dONLNdj
}N
ç
Á(
®l?Closures and Perform (10/9/93) (Obsoleted by NS Guide 1.0 Final°dONLNd™
çN
ùµ*Documentation)

°dONLNdπ
©N
µ[*Q: °dONLNdΩ
©`
µ
“)QThe NewtonScript manual indicates that the receiver during a call is the receiver°dONLNd
µ`
¡
*)that made the call. For example, the code°dONLNd=
Õr
ŸÖ+a := °dONLNdB
ÕÖ
Ÿã)
{°dONLNdD
ŸN
Âf(
l    °dONLNdI
Ÿr
¢)$id: "a",°dONLNdR
‰N
f(l    °dONLNdW
‰r
ˆ)$foo: func() Print(id),°dONLNdo
Ôr
˚~*};°dONLNdurñ*b := {°dONLNd|Nf(8l    °dONLNdÅr¢)$id: "b",°dONLNdäN'f(Cl    °dONLNdèr'
,)$bar: func() call a.foo with (),°dONLNd∞&r2~*};°dONLNd∂<rH¢*b:bar();°dONLNd¬S`_¨({~should print "b".°dONLNd◊k`w
Ã*QWhen I run this in an Inspector, however, it appears that the receiver during the°dONLNd)w`É
Œ*Texecution of foo() is the top level frame in which a (and b) is defined.  How is the°dONLNd~É`è
≠*Kreceiver actually determined?  Is it always the top level of the Inspector?
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û17ˇ
†◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd5NA[*2A: °dONLNd5`A
Ÿ)SWhat you really create is a closure, which is the executable code bound up with the°dONLNdXA`M
 *Pdynamic and lexical environments at the time the function was created.  That is,°dONLNd©M`Y
fl*Rwhatever self evaluated to when the function was compiled is what it will evaluate°dONLNd¸Y`e∑*to when it's called.°dONLNd
q`}
fi*SThe Perform  call, or message-passing does change the closure's dynamic environment°dONLNd
f}`â
Æ*K(self) to the frame that was specified by the message pass or Perform call.°dONLNd
≥ï`°
`*9To do what you seem to be attempting, you could try this:,
Courier°dONLNd
Ó≠rπñ+a := {°dONLNd
ı∏Nƒf(‡l    °dONLNd
˙∏rƒ¢)$id: "a",°dONLNd√Nœ`(Îl   °dONLNd√rœ¸)$foo: func() Print(id)};°dONLNd ŸrÂñ*b := {°dONLNd'‰Nf(
l    °dONLNd,‰r¢)$id: "b",°dONLNd5ÔN˚f(
l    °dONLNd:Ôr˚
§)$3bar: func() begin self.temp := a.foo; :temp() end};°dONLNdp
r
¢*b:bar();°dONLNdz
`
(
À(
D~SInstead of :temp() above, you could have used Perform(self, 'temp, []);  Perform is°dONLNdŒ
(`
4
Ã*Mhandy when you don't know at compile time which message you need to pass. For°dONLNd
4`
@
◊*Sexample, you can write Perform(self, jumpTable[i], []); where jumpTable contains an°dONLNdp
@`
L
…*Narray of symbols representing methods. Perform takes a frame, a message and an°dONLNdø
L`
XÂ*array of message parameters.,    Helvetica
°dONLNd›
dN
v
¸(
ël+___________________________________________
°dONLNd    
vN
Ü
À*:Symbol Hacking (11/11/93) (Obsoleted by NS Guide 1.0 Final°dONLNdD
ÜN
ñµ*Documentation)

°dONLNdS
¶N
≤Y*Q:°dONLNdV
¶`
≤
⁄)RI would like to be able to build frames dynamically and have my application create°dONLNd©
≤`
æ
⁄*Tthe name of the slot in the frame dynamically as well.  For instance, something like°dONLNd˛
æ`
 v*this:°dONLNd
 r
÷
J+$MyFrame:= {}; tSlotName := "Slot_1";°dONLNd-
·`
Ì
=(    ~3At this point is there a way to then create this ?:°dONLNdb
Ìr
˘Δ+MyFrame.Slot_1°dONLNdqNY(8lA:°dONLNdt`
„)XThere is a function called Intern, that takes a string and makes a symbol. There is also°dONLNdÕ`(
”*Na mechanism called path expressions (see the NewtonScript manual), that allows°dONLNd(`4
fl*Xyou to specify an expression or variable to evaluate, in order to get the slot name. You°dONLNdu4`@
8*2can use these things to access the slots you want:°dONLNd©LrX¸+MyFrame := {x: 4} ;    °dONLNd¬L
&X
û)¥// MyFrame -->{x: 4}°dONLNdÿcro¸(ãêtheXSlotString := "x" ;°dONLNdÒnrz
P*%MyFrame.(Intern(theXSlotString)) := 6°dONLNdyñÖú+$
 °dONLNdy
&Ö
§)ê// MyFrame --> {x: 6}°dONLNd6êrú
(∏êtSlotName := "Slot_1" ; °dONLNdOê
&ú
⁄)¥// the following code creats a
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û18ˇ
.◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd)
&5
˛+ÿ&$// slot called Slot_1 in MyFrame and°dONLNd,4
&@
Œ*// assigns it the number 7. °dONLNdI?rK
>(gê"MyFrame.(Intern(tSlotName)) := 7 ;°dONLNdxJ
&V
Ê+¥ // MyFrame --? {x: 6, Slot_1: 7}°dONLNdöaNmY(âlQ:°dONLNdùarm
È)$TIs there a way to look for a slot programmatically starting with a slot name string?°dONLNdÚyNÖY(°lA:°dONLNdıyrÖ
)$"Here's the code which can do this:°dONLNd
Örë
t*+if MyFrame.(Intern(slotToFind)) exists then°dONLNd
Gêrú
Œ*:      x := MyFrame.(Intern(slotToFind)) ;  // use the slot,    Helvetica
°dONLNd
Ö≠Nø
¸(⁄l+___________________________________________
°dONLNd
±øNœ
* Literals and run time (11/11/93)

°dONLNd
“€NÁY*Q:°dONLNd
’€`Á
À)UIs the literals slot really needed during run time? I noticed that I could figure out°dONLNd+Á`Û
‚*Vquite a lot about how my functions work from the literals used (examining the literals°dONLNdÇÛ`ˇ
◊*Wslot). I would rather not make it easy for others to reverse engineer certain routines.°dONLNd⁄
N
Y(
3lA:°dONLNd›
`

’)TThe literals slot is indeed needed during run time (in the current implementation of°dONLNd2
`
#
®*INewtonScript) The interpreter is using it at run time. Here's an example:°dONLNd}
/r
;v+
f°dONLNd~
/v
;‹) := func() "abc";°dONLNdë
;r
G
V(
cêᄹCB9  <CodeBlock, 0 args #4409CB9>°dONLNdπ
Fr
RÆ*
f.literals°dONLNd≈
Qr
]
*#4409B61  [literals: "abc"]°dONLNd‚
\r
h
*f.literals[0] := {foo: 'bar}°dONLNd
gr
sÍ*#440A1D1  {foo: bar}°dONLNd
rr
~Δ*call f with ()°dONLNd&
}r
âÍ*#440A1D1  {foo: bar}°dONLNd<
î`
†
‚(
º~TDon't assume anything about the implementation of the literals slot in future Newton°dONLNdë
†`
¨¨*system software.
°dONLNd£
ºN
Œ
¸(
Èl+___________________________________________
°dONLNdœ
ŒN
fi
˙*AMissing Semicolons cause Weird Errors (12/11/93) (Obsoleted by NS°dONLNd
fiN
Ó
*Guide 1.0 Final Documentation)

°dONLNd0
˙N
Á*\As with Pascal, semicolons are statement separators, not terminators. If you forget to add a°dONLNdçO
‰+
[semicolon at the end of the Newtonscript statement, the interpreter will try to interpret a°dONLNdÈO
b*>larger statement than intended, causing strange error reports.°dONLNd(*N6
(Rl+The following is an example of such a case.°dONLNdTBNN
«*UYou are getting an "expected array, frame, or binary but got 8" exception because you°dONLNd™NNZ¡*wrote the following code:°dONLNdƒfNrR*  °dONLNdΔfRr
¥);   :Emit(dest, 'subprim, "Send", [t2, t1, Length(node.r3)])°dONLNdqN}Δ(ôl     :PopTemp('ref);°dONLNdàNî
d*@Note the missing semicolon on the first line.  This is parsed as
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û19ˇ◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd5NA
2*2&     (:Emit(blah blah)):PopTemp('ref);°dONLNd'LNX
˜*^The :Emit call resulted in an 8, which was used as the receiver for the PopTemp message.  This°dONLNdÜXOd

+
%was NOT what the programmer intended.°dONLNd¨pN|
˛(òl]There are two habits that would have prevented this error. You might want to consider them as°dONLNd

|Oà
Î+
\part of your personal coding style, though neither of them is extremely important since this°dONLNd
gàOî¶*error is pretty rare.°dONLNd
îN†
%(ºl6        - Always use "self:foo()" instead of ":foo()".°dONLNd
∂†N¨
»*Y        - Always put a semicolon at the end of a statement, even  when you don't need to.,    Helvetica
°dONLNdºNŒ
¸*!+___________________________________________
°dONLNd=ŒNfi
¡*5Classical OOP programming withNewtonScript (12/17/93)°dONLNdsfiNÓ
â*/(Obsoleted by NS Guide 1.0 Final Documentation)

°dONLNd•˙N

“*XQ:  I would like to see the ability to use more of a C++ approach, where I could inherit°dONLNd˛
`
Ç+code — °dONLNd
ñ

‹)6Hnot necessarily user-interface (view) oriented code — with functionality°dONLNdO
`
®(
:~like templates. °dONLNdc
*N
6
‚(
RlXA: You can easily simulate most aspects of traditional class-instance OO programming (as°dONLNdº
6`
B
‹+Sin Smalltalk or C++) using NewtonScript.  There aren't any specific features in NTK°dONLNd
B`
N
Ÿ*W1.0 to support this, but you can do it without too much trouble, using the Project Data°dONLNdh
N`
Zá*window.°dONLNdq
f`
r
ÿ*TThe basic idea is to use _parent inheritance to provide the link between "instances"°dONLNdΔ
r`
~
‚*Wand "classes".  You define a frame in the Project Data to hold the methods (this is the°dONLNd
~`
ä
—*T"class"), and you construct "instances" whose slots are the "instance variables" (or°dONLNds
ä`
ñ
ÿ*T"members" if you prefer C++).  Quotes will continue to be used around these words to°dONLNd»
ñ`
¢
÷*Temphasize that there is no built-in concept of a class in NewtonScript; we are using°dONLNd
¢`
Æ
∫*Kthe prototype-based inheritance system to simulate class-based inheritance.°dONLNdj
∫`
Δ
fi*VSuppose we want to create a "class" to represent a stack.  We will represent the stack°dONLNd¡
Δ`
“
‚*Was an array.  Each "instance" needs to store the array and the index of the top element°dONLNd
“`
fi
:*3of the stack, so an "instance" will look like this:°dONLNdN
ÍN
ˆ
º(l=    { _parent: ...,                 // pointer to the "class"°dONLNdå
ıN

å*5      items: [...],                 // array of items°dONLNd¬N
û*8      topIndex: 2 }                 // index of top item°dONLNd¸`#
+*The "class" contains the methods, like so:°dONLNd'/r;¢+Stack :=°dONLNd6:ñF
D+${ Push:     func (item) begin°dONLNdTErQ
∞(mê5                            topIndex := topIndex + 1;°dONLNdäPr\
™*4                            items[topIndex] := item;°dONLNdø[rg
2*                             self°dONLNd‡frr
*                        end,°dONLNd    |rà
P*%              Pop:      func () begin°dONLNd    ,árì
Ü*.                            if :IsEmpty() then°dONLNd    [írû
D*#                                NIL
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û20ˇ
⁄◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd)r5
V+$&&                            else begin°dONLNd'4r@
Ê*>                                local item := items[topIndex];°dONLNdf?rK
º*7                                items[topIndex] := NIL;°dONLNdûJrV
»*9                                topIndex := topIndex - 1;°dONLNdÿUra
J*$                                item°dONLNd˝`rl
,*                            end°dONLNd
krw
*                        end,°dONLNd
CÅrç
,*              IsEmpty:  func ()°dONLNd
cårò
n**                            topIndex = -1,°dONLNd
é¢rÆ
P*%              Clone:    func () begin°dONLNd
¥≠rπ
∞*5                            local new := Clone(self);°dONLNd
Í∏rƒ
Œ*:                            new.items := Clone(new.items);°dONLNd%√rœ
,*                            new°dONLNdEŒr⁄
*                        end,°dONLNdb‰r
,*              New:      func ()°dONLNdÇÔr˚
t*+                            {_parent: self,°dONLNdÆ˙r

§*3                             items: Array(10, NIL),°dONLNd‚
r

n**                             topIndex: -1}°dONLNd

r
¿*
            }°dONLNd
&`
2
…(
N~RObviously, this ignores such niceties as stretching the array and signalling error°dONLNdo
2`
>˘*$conditions, for the sake of clarity.°dONLNdï
J`
V
¢*GTo get a new Stack "instance", you send the New message to the "class":°dONLNd›
br
n+    s := Stack:New();°dONLNdÙ
y`
Ö
9(
°~0Now you can send messages to s to get work done:°dONLNd%
ër
ùΔ+    s:Push('a)°dONLNd4
úr
®“*    x := s:Pop()°dONLNdE
ßr
≥
*    if s:IsEmpty() then ...°dONLNda
≤r
æ‰*    s2 := s:Clone()°dONLNdu
Ωr
…¥*    // etc.°dONLNdÇ
‡`
Ï
‹(~UYou can put "class variables" and "class methods" in the "class" if you want; they're°dONLNdÿ
Ï`
¯
«*Qall the same thing in this model, just slots of the "class". The New method is an°dONLNd*
¯`
—*Sexample.  Note that you can get a new instance from an old instance (i.e., s:New())°dONLNd~`ø*because of this unity.°dONLNdñ`(
…*LThose who have been paying attention to the Listener output may already have°dONLNd„(`4
‘*Unoticed this method of programming, because it is used by soups, stores, and cursors.°dONLNd:4`@
⁄*Q(But you should assume that anything undocumented you notice in the Inspector may°dONLNdå@`LÂ*be changed in the next ROM.)°dONLNd™X`d
⁄*TTo use this technique in NTK, you can put the "class" in the Project Data window. To°dONLNdˇd`p
‡*[access it from your code, you'll need to put a slot that refers to it in your main view (or°dONLNd[p`|
fl*Vlower down if you don't need the class throughout your application).  You can just add°dONLNd≤|`à
Ã*Ta slot called "Stack" whose value is "Stack", or if you prefer, you can use distinct°dONLNdà`î
Å*?names (for example, call it "StackClassFrame" in Project Data).,    Helvetica
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û21ˇ
“◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language

°dONLNd5`A
÷+2SHere's an example, in NTK text-export form.  This does not include the project data°dONLNdTA`M
µ*Rsection, because it looks just like the "Stack :=" section above.  This is just an°dONLNdßM`Y
€*Uapplication with a button that prints "30" in a complicated way using a stack object.,
Courier°dONLNd˝Yreú+main :=°dONLNd
drpÿ*   {title: "xxx",°dONLNd
or{
⁄*<    viewBounds: {left: -1, top: 0, right: 236, bottom: 333},°dONLNd
TzrÜÿ*    Stack: Stack,°dONLNd
fÖrë*    _proto: protoapp,°dONLNd
|êrúê*   };°dONLNd
Ƕr≤
,*_view000 := /* child of main */°dONLNd
¢±rΩ‰*   {text: "Button",°dONLNd
∂ºr»ˆ*    buttonClickScript:°dONLNd
Õ«r”∫*      func()°dONLNd
⁄“rfi¥*      begin°dONLNd
Ê›rÈ
2*          local s := Stack:New();°dONLNdËrÙÍ*         s:Push(10);°dONLNdÛrˇÍ*         s:Push(20);°dONLNd1˛r


8*!         Print(s:Pop() + s:Pop())°dONLNdS
    r
Æ*
      end,°dONLNd^
r
 
‡*=    viewBounds: {left: 74, top: 74, right: 154, bottom: 106},°dONLNdú
r
+
*    _proto: prototextbutton°dONLNd∏
*r
6ê*   };°dONLNdø
L`
X
‘(
t~UYou can use an extended form of this technique to put an object-oriented interface on°dONLNd
X`
d
À*Qsoup entries.  "Wrap" the soup entry in an "instance" frame like the one above by°dONLNdg
d`
p
‚*Xpointing a slot of the "instance" to the soup entry.  You can have "class methods" to do°dONLNd¿
p`
|
‚*Vqueries and return these "instances". You can also have  "instance methods" to change,°dONLNd
|`
à
‹*Xvalidate, undo, flush, and so on.  You can also choose _proto as the slot that points to°dONLNdp
à`
î
”*Tthe soup entry, so you inherit the entry's slots--but remember that slot assignments°dONLNd≈
î`
†
*+will go into the "instance", not the entry.°dONLNdÚ
¨`
∏
»*SIf you're intrigued by all this, see  the various papers on the language "Self", by°dONLNdF
∏`
ƒ
∂*JUngar, Chambers, and others at Stanford (now at SunSoft).  Many aspects of°dONLNdë
ƒ`
–
Œ*QNewtonScript were inspired by Self. The postscript files are available via ftp on°dONLNd„
–`
‹Ì* Internet from self.stanford.edu.,    Helvetica
°dONLNd
ˆN
¸(#l+___________________________________________
°dONLNd1N
Ú*@Only 7-Bit ASCII In NewtonScript Symbols (1/26/94) (Obsoleted by°dONLNdrN(
0*!NS Guide 1.0 Final Documentation)

°dONLNdî8NDY*Q:°dONLNdó8`D
fi)TMy frame has some slot symbols that contain accent and special letters. For example:°dONLNdÌPr\
‡+=f := {|à|:"help me please", |é|:"Thanks in advance", ...,...}°dONLNd,g`s
fi(è~TMy program received a letter from ProtoInputLine and turned it into a symbol. I have°dONLNdÅs`
≤*Ntried many different ways to do this but I could not convert it into a symbol.°dONLNd—ãNóY(≥lA:°dONLNd‘ã`ó
i)=The basic problem is you can only use 7-bit ascii in symbols.
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û22ˇí◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,    Helvetica
°dONLNdˇˇ*7+___________________________________________
°dONLNdGNW
Õ*:Nested IF Statements, Constant Condition Problems (6/9/94)

°dONLNd;gNs[*Q: °dONLNd?g`s
◊)TI have found a mysterious problem with Scripts containing  nested IFs. In some cases°dONLNdîs`
å*@like the following example they are executed in an abnormal way.°dONLNd÷ã`ó
‡*XThe true conditions in the real code are constants defined in the project data file with°dONLNd
/ó`£
j*=values true or nil. These are used for conditional compiling.,
Courier°dONLNd
nØrª
V+&protoApp.viewSetupDoneScript : FUNC ()°dONLNd
ñ∫rΔê*begin°dONLNd
ú≈N—T(Ìl
 °dONLNd
û≈r—∫)$if TRUE then°dONLNd
´–N‹f(¯l    °dONLNd
∞–r‹ê)$begin°dONLNd
∂€NÁl(
l     °dONLNd
º€rÁ∫)$if TRUE then°dONLNd
…ÊNÚ~(
l        °dONLNd
“ÊñÚ¥)Hbegin°dONLNd
ÿÒN˝Ñ(
l             °dONLNd
‚Òñ˝fi)Hif TRUE then°dONLNd
Ô¸N
¥(
$l            begin°dONLNd

N
ú*
             °dONLNd
∫

)lif TRUE then°dONLNd
N
Æ(
:l                °dONLNd-
∫
ÿ)lbegin°dONLNd3
N
)∫(
El                  °dONLNdF
fi
)
b)êPrint ("Idlescript1");°dONLNd]
(N
4®(
Pl               °dONLNdm
(∫
4Ã)lend°dONLNdq
3N
?®(
[l            end°dONLNdÅ
>N
Jê*        end°dONLNdç
IN
Uf*    °dONLNdí
Ir
Uä)$end;°dONLNdó
TN
`Z(
|l  °dONLNdö
Tr
`ˆ)$Print ("Idlescript2");°dONLNd≤
_r
kÑ*end°dONLNd∑
v`
Ç
π(
û~OThere should be only two prints. In fact there are five prints in the following°dONLNd
Ç`
éÑ*manner:°dONLNd
ôr
•¿+
"Idlescript1"°dONLNd 
§r
∞¿*
"Idlescript1"°dONLNd/
Ør
ª¿*
"Idlescript1"°dONLNd>
∫r
Δ¿*
"Idlescript1"°dONLNdM
≈r
—¿*
"Idlescript2"°dONLNd\
€`
Á
“(~VIf I define Boolean slots with value truein the base view, and if I use those slots as°dONLNd≥
Á`
Û
„*Vconditions, the code works like it should. Why can nested IFs with constant conditions°dONLNd

Û`
ˇØ*work like a loop?°dONLNdN#[(?lA: °dONLNd!`#
œ)SThis is a bug in the compiler's handling of IF statements with constant conditions.°dONLNdv#`/
∑*PThe bug occurs only if the result of the IF statement is not used.  For example,°dONLNd«:NF¥(bl    func () begin°dONLNdŸENQΔ*        if TRUE then°dONLNdÓPN\fi*            if TRUE then°dONLNd[Ng‰*                Print(1);°dONLNd!fNr¥*        Print(2);°dONLNd3qN}x*    end°dONLNd<à`îÀ+will trigger the bug, but
°dONLNdˇˇ(≈H=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û23ˇÏ◊#ˇˇˇˇˇ#◊

d,Palatino
    .+l+!Newtonscript Programming Language,
Courier

°dONLNd5NA¥*2    func () begin°dONLNd@NL
*        local x := if TRUE then°dONLNd2KNW
 *#                       if TRUE then°dONLNdVVNb
&*$                           Print(1);°dONLNd{aNm¥*        Print(2);°dONLNdçlNxx*    end°dONLNdñÇ`éá+    will not.°dONLNd°ö`¶
*+The workaround is to use the result of the °dONLNdÃö
¶
.)ºif °dONLNdœö
.¶
œ)$statement.  You don't really want to°dONLNdÙ¶`≤
»(Œ~Okeep the result around, so the above example is not recommended .  The simplest°dONLNd
E≤`æ
*%workaround is probably the following:°dONLNd
k N÷R(Úl  °dONLNd
m R÷¨)  func () begin°dONLNd
}’N·Ñ(˝l            (°dONLNd
á‡NÏfi*            if TRUE then°dONLNd
†ÎN˜ˆ*                if TRUE then°dONLNd
ΩˆN
¸*                    Print(1);°dONLNd
€

N

¿*        ) and TRUE;°dONLNd
Ô
N
¥*        Print(2);°dONLNd

N
#x*    end°dONLNd

.`
:
fi+RThis works because the NTK 1.0.1 compiler does not throw away the "and true" part,°dONLNd]
:`
F
@*2but the result of the "if" is dropped immediately.,    Helvetica
°dONLNdë
^N
p
¸(
ãl+___________________________________________
°dONLNdΩ
pN
Ä
}*,NEW: How to Avoid _parent Problems (6/28/94)

°dONLNdÍ
åN
òY*Q:°dONLNdÌ
å_
ò
Ÿ)RI read somewhere that developers should never access a view _parent slot directly?°dONLNd@
ò_
§
s*?Are there any cases when it is safe to access the _parent slot?°dONLNdÄ
∞N
ºY(
ÿlA:°dONLNdÉ
∞_
º
ÿ)SIn most cases, you should use the :Parent() view method to determine a parent view.°dONLNd◊
º_
»
Œ*PHowever, there are some cases when you want to access the _parent slot of a view°dONLNd(
»_
‘
”*Tdirectly.  The situation which is bad is to use _parent as a simple variable because°dONLNd}
‘_
‡
¥*Kresults will vary depending on implementation of the current function. Some°dONLNd…
‡_
Ïë*guidelines:°dONLNd’
ÏN
¯~(l        °dONLNdfi
Ïñ
¯fi)H _parent    °dONLNdÍ
Ïfi
¯˘)His bad°dONLNdÒ
¯Nfi( l         view:Parent()  °dONLNd    
¯fi¯)êis OK°dONLNdNfi(,l        self._parent    °dONLNd'fi
¢)ê+is OK (and should be the same as :Parent())°dONLNdSNfi(8l        view._parent    °dONLNdkfi
π)ê/is OK (and should be the same as view:Parent())
°dONLNdõ@*R
Ï(mH-_____________________________________________
°dONLNdˇˇ*X=© Copyright 1993-94 Apple Computer, Inc, All Rights Reserved °dONLNdˇˇ)◊7/7/94
    °dONLNdˇˇ)Û24ˇ